@aion0/forge 0.5.42 → 0.5.44

package/lib/workspace/watch-manager.ts

@@ -21,10 +21,18 @@ interface WatchSnapshot {
   gitHash?: string;
   commandOutput?: string;
   logLineCount?: number;   // last known line count in agent's logs.jsonl
-  agentStatus?: string;    // last known taskStatus of monitored agent
+  /** Per-target last-seen taskStatusChangedAt. Watch fires when the target's
+   *  current taskStatusChangedAt > the value recorded here. Updated only after
+   *  a successful (non-defer) match-check. */
+  agentStatusLastSeen?: Record<string, number>;
   sessionFileSize?: number; // last known file size of session JSONL (bytes)
 }
 
+/** Statuses that mean "still working — defer firing until it settles". */
+function isBusyStatus(s: string | undefined): boolean {
+  return s === 'running' || s === 'starting';
+}
+
 interface WatchChange {
   targetType: WatchTarget['type'];
   description: string;
@@ -330,7 +338,7 @@ export class WatchManager extends EventEmitter {
   constructor(
     private workspaceId: string,
     private projectPath: string,
-    private getAgents: () => Map<string, { config: WorkspaceAgentConfig; state: { smithStatus: string; taskStatus: string; mode: string } }>,
+    private getAgents: () => Map<string, { config: WorkspaceAgentConfig; state: { smithStatus: string; taskStatus: string; mode?: string; taskStatusChangedAt?: number } }>,
   ) {
     super();
   }
@@ -346,9 +354,7 @@ export class WatchManager extends EventEmitter {
 
   /** Stop all watch loops */
   stop(): void {
-    for (const [id, timer] of this.timers) {
-      clearInterval(timer);
-    }
+    for (const timer of this.timers.values()) clearInterval(timer);
     this.timers.clear();
     console.log(`[watch] All watch loops stopped`);
   }
@@ -392,7 +398,9 @@ export class WatchManager extends EventEmitter {
     const now = Date.now();
     const prev = this.snapshots.get(agentId) || { lastCheckTime: now };
     const allChanges: WatchChange[] = [];
-    const newSnapshot: WatchSnapshot = { lastCheckTime: now };
+    const newSnapshot: WatchSnapshot = {
+      lastCheckTime: now,
+    };
 
     for (const target of config.watch!.targets) {
       switch (target.type) {
@@ -456,25 +464,58 @@ export class WatchManager extends EventEmitter {
           break;
         }
         case 'agent_status': {
-          // Monitor another agent's task status (running → done/failed)
-          const targetAgentId = target.path; // path = agent ID to monitor
-          if (targetAgentId) {
-            const agents = this.getAgents();
-            const targetEntry = agents.get(targetAgentId);
-            if (targetEntry) {
-              const currentStatus = targetEntry.state.taskStatus;
-              const prevStatus = prev.agentStatus;
-              newSnapshot.agentStatus = currentStatus;
-              if (prevStatus && prevStatus !== currentStatus) {
-                const label = targetEntry.config.label;
-                // Match pattern if specified (e.g., "done" or "failed")
-                const pattern = target.pattern;
-                if (!pattern || currentStatus.match(new RegExp(pattern, 'i'))) {
-                  allChanges.push({ targetType: 'agent_status', description: `Agent ${label} status: ${prevStatus} → ${currentStatus}`, files: [] });
-                }
-              }
-            }
+          // Event-driven detection via taskStatusChangedAt timestamp on the target
+          // agent's state (orchestrator updates it on every real transition).
+          // The watch tick just compares timestamps — no fast-tick polling needed.
+          const targetAgentId = target.path;
+          if (!targetAgentId) break;
+          const agents = this.getAgents();
+          const targetEntry = agents.get(targetAgentId);
+          if (!targetEntry) break;
+
+          const cur = targetEntry.state.taskStatus;
+          const curChangedAt = targetEntry.state.taskStatusChangedAt || 0;
+          const lastSeenMap = newSnapshot.agentStatusLastSeen || (newSnapshot.agentStatusLastSeen = { ...(prev.agentStatusLastSeen || {}) });
+
+          // Initial run: record current changedAt so we don't fire on the
+          // existing state. Future transitions will advance the timestamp.
+          if (initialRun) {
+            lastSeenMap[targetAgentId] = curChangedAt;
+            console.log(`[watch] ${config.label}: agent_status baseline — ${targetEntry.config.label}=${cur} @ ${curChangedAt}`);
+            break;
+          }
+
+          const prevSeen = lastSeenMap[targetAgentId] || 0;
+
+          // No transition since last check.
+          if (curChangedAt <= prevSeen) {
+            console.log(`[watch] ${config.label}: ${targetEntry.config.label} no transition since last check (curAt=${curChangedAt})`);
+            break;
+          }
+
+          // Target is mid-transition (still busy) — defer; do NOT update lastSeen
+          // so the next interval-tick can still see this as a pending transition.
+          if (isBusyStatus(cur)) {
+            console.log(`[watch] ${config.label}: ${targetEntry.config.label} = ${cur} (busy) → defer`);
+            break;
+          }
+
+          // Settled state. Match pattern against final state only.
+          const pattern = target.pattern;
+          const matched = pattern ? !!cur.match(new RegExp(pattern, 'i')) : true;
+          if (matched) {
+            console.log(`[watch] ${config.label}: ${targetEntry.config.label} → ${cur} (changed since ${prevSeen}) pattern='${pattern || '(any)'}' → FIRE`);
+            allChanges.push({
+              targetType: 'agent_status',
+              description: `Agent ${targetEntry.config.label} settled to ${cur}${pattern ? ` (matched '${pattern}')` : ''}`,
+              files: [],
+            });
+          } else {
+            console.log(`[watch] ${config.label}: ${targetEntry.config.label} → ${cur} pattern='${pattern}' → no match`);
           }
+          // Mark this transition as seen, so we don't fire again until the next
+          // real transition advances the timestamp.
+          lastSeenMap[targetAgentId] = curChangedAt;
           break;
         }
       }

package/lib/workspace-standalone.ts

@@ -312,10 +312,9 @@ async function handleAgentsPost(id: string, body: any, res: ServerResponse): Pro
         if (body.resolveOnly) {
           let currentSessionId: string | null = null;
           if (agentConfig.primary) {
-            try {
-              const { getFixedSession } = await import('./project-sessions.js');
-              currentSessionId = getFixedSession(orch.projectPath) || null;
-            } catch {}
+            // Auto-bind to project's latest existing session if no fixedSession yet,
+            // so the picker can offer "Current Session" on a fresh workspace.
+            currentSessionId = orch.resolvePrimaryFixedSession();
           } else {
             currentSessionId = agentConfig.boundSessionId || null;
           }
@@ -744,11 +743,8 @@ async function handleSmith(id: string, body: any, res: ServerResponse): Promise<
       // Get the primary agent's tmux session + project-level fixed session
       const primary = orch.getPrimaryAgent();
       if (!primary) return json(res, { ok: false, error: 'No primary agent configured' });
-      let fixedSessionId: string | null = null;
-      try {
-        const { getFixedSession } = await import('./project-sessions.js');
-        fixedSessionId = getFixedSession(orch.projectPath) || null;
-      } catch {}
+      // Auto-bind to project's latest existing session if no fixedSession yet.
+      const fixedSessionId = orch.resolvePrimaryFixedSession();
       return json(res, {
         ok: true,
         agentId: primary.config.id,

package/next-env.d.ts

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

package/package.json

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

package/vscode-extension/.vscodeignore

@@ -0,0 +1,11 @@
+.vscode/**
+.vscode-test/**
+src/**
+.gitignore
+.yarnrc
+vsc-extension-quickstart.md
+tsconfig.json
+**/.eslintrc.json
+**/*.map
+**/*.ts
+package-lock.json

package/vscode-extension/README.md

@@ -0,0 +1,48 @@
+# Forge VSCode Extension
+
+Native VSCode integration for [Forge](https://github.com/aiwatching/forge).
+
+## What it does
+
+- **Sidebar** — workspaces, smiths, active terminals, and background tasks at a glance
+- **Native terminals** — attach to or create Forge tmux sessions in VSCode's terminal panel (uses VSCode's own Pseudoterminal API; sessions show up next to your regular terminals)
+- **Send selection** — pipe selected code to a running Forge terminal
+- **Notifications** — smith bell events surface as VSCode notifications
+- **Status bar** — connection indicator + quick command access
+
+## Setup
+
+1. Install Forge CLI: `npm install -g @aion0/forge`
+2. Start the server: `forge server start`
+3. Install this extension (VSCode → "Install from VSIX..." or marketplace)
+4. Cmd/Ctrl+Shift+P → `Forge: Login` → enter your admin password
+
+The token is stored in VSCode's SecretStorage and reused across sessions.
+
+## Settings
+
+| Key | Default | Description |
+|-----|---------|-------------|
+| `forge.serverUrl` | `http://localhost:8403` | Forge HTTP server |
+| `forge.terminalUrl` | `ws://localhost:8404` | Terminal WebSocket |
+| `forge.autoStart` | `false` | Spawn `forge server start` on activation if unreachable |
+| `forge.notifications.enabled` | `true` | Smith-bell → VSCode notification |
+| `forge.refreshInterval` | `5` | Tree refresh interval (seconds) |
+
+## Local install
+
+```bash
+cd vscode-extension
+npm install
+npm run package        # produces forge-vscode.vsix
+code --install-extension forge-vscode.vsix
+```
+
+## Develop
+
+```bash
+cd vscode-extension
+npm install
+npm run watch          # in one terminal
+# In VSCode: F5 to launch Extension Development Host
+```

package/vscode-extension/media/icon.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor">
+  <path d="M12 2L3 7v6c0 5 3.5 9.5 9 11 5.5-1.5 9-6 9-11V7l-9-5zm0 4.5l5 2.8v3.4l-5-2.8-5 2.8V9.3l5-2.8zm-5 6.4l5 2.8v5.6c-3.4-1.4-5-4.6-5-7.6v-.8zm10 .8c0 3-1.6 6.2-5 7.6v-5.6l5-2.8v.8z"/>
+</svg>