@aion0/forge 0.5.40 → 0.5.43

package/lib/workspace/types.ts

@@ -99,6 +99,19 @@ export interface AgentState {
   // ─── Task layer (current work) ──────────
   taskStatus: TaskStatus;             // idle/running/done/failed
 
+  // Transient runtime flag — paused smith ignores bus pickups, drops new
+  // incoming messages as failed, and suppresses watch alerts. Never persisted;
+  // any daemon stop/start or process restart clears it.
+  paused?: boolean;
+
+  // Transient: timestamp of the most recent taskStatus *change* (idempotent
+  // re-emits of the same value don't update this). Used by agent_status watches
+  // to detect transitions without polling. Reset to Date.now() on load.
+  taskStatusChangedAt?: number;
+  // Transient: previous taskStatus value, used by orchestrator's event listener
+  // to dedup idempotent emits. Reset to current taskStatus on load.
+  lastTaskStatus?: TaskStatus;
+
   // ─── Execution details ──────────────────
   currentStep?: number;
   history: TaskLogEntry[];

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

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

package/start.sh

@@ -24,6 +24,29 @@ export PORT=${PORT:-8403}
 export TERMINAL_PORT=${TERMINAL_PORT:-8404}
 export WORKSPACE_PORT=${WORKSPACE_PORT:-8405}
 
+# pnpm is the pinned package manager (see package.json#packageManager).
+# Try corepack first (ships with Node 16.9+), then fall back to a prompt.
+if ! command -v pnpm >/dev/null 2>&1; then
+  if command -v corepack >/dev/null 2>&1; then
+    echo "[forge] pnpm not found — enabling via corepack..."
+    corepack enable 2>/dev/null || true
+    corepack prepare pnpm@latest --activate 2>/dev/null || true
+  fi
+fi
+if ! command -v pnpm >/dev/null 2>&1; then
+  echo "[forge] pnpm is required but was not found on PATH."
+  echo "[forge] Install it with:"
+  echo "    npm install -g pnpm"
+  echo "[forge] Then re-run: ./start.sh ${1:-}"
+  exit 1
+fi
+
+# Install dependencies if node_modules is missing or the next binary isn't built
+if [ ! -x node_modules/.bin/next ]; then
+  echo "[forge] node_modules missing — running pnpm install..."
+  pnpm install || exit 1
+fi
+
 if [ "$1" = "dev" ]; then
   export FORGE_DEV=1
   pnpm dev

package/.forge/agent-context.json

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