@aion0/forge 0.5.42 → 0.5.43

package/RELEASE_NOTES.md

@@ -1,8 +1,11 @@
-# Forge v0.5.42
+# Forge v0.5.43
 
-Released: 2026-04-23
+Released: 2026-04-25
 
-## Changes since v0.5.41
+## Changes since v0.5.42
 
+### Features
+- feat: smith pause/resume + agent_status watch event-driven + primary session picker
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.41...v0.5.42
+
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.42...v0.5.43

package/components/Dashboard.tsx

@@ -148,6 +148,11 @@ export default function Dashboard({ user }: { user: any }) {
   }, []);
   useEffect(() => { refreshDisplayName(); }, [refreshDisplayName]);
 
+  // Reflect the current user's name in the browser tab title
+  useEffect(() => {
+    document.title = displayName && displayName !== 'Forge' ? `Forge — ${displayName}` : 'Forge';
+  }, [displayName]);
+
   // Listen for open-terminal events from ProjectManager
   useEffect(() => {
     const handler = (e: Event) => {
@@ -278,7 +283,9 @@ export default function Dashboard({ user }: { user: any }) {
       <header className="h-12 border-b-2 border-[var(--border)] flex items-center justify-between px-4 shrink-0 bg-[var(--bg-secondary)]">
         <div className="flex items-center gap-4">
           <img src="/icon.png" alt="Forge" width={28} height={28} className="rounded" />
-          <span className="text-sm font-bold text-[var(--accent)]">Forge</span>
+          <span className="text-sm font-bold text-[var(--accent)]">
+            Forge{displayName && displayName !== 'Forge' ? ` · ${displayName}` : ''}
+          </span>
           {versionInfo && (
             <span className="flex items-center gap-1.5">
               <span className="text-[10px] text-[var(--text-secondary)]">v{versionInfo.current}</span>

package/components/WorkspaceView.tsx

@@ -34,6 +34,7 @@ interface AgentConfig {
 interface AgentState {
   smithStatus: 'down' | 'starting' | 'active';
   taskStatus: 'idle' | 'running' | 'done' | 'failed';
+  paused?: boolean;
   currentStep?: number;
   tmuxSession?: string;
   artifacts: { type: string; path?: string; summary?: string }[];
@@ -2794,6 +2795,7 @@ interface AgentNodeData {
   workspaceId: string | null;
   onRun: () => void;
   onPause: () => void;
+  onResume: () => void;
   onStop: () => void;
   onRetry: () => void;
   onEdit: () => void;
@@ -3307,7 +3309,7 @@ function WorkerMascot({ taskStatus, smithStatus, seed, accentColor, theme }: { t
 }
 
 function AgentFlowNode({ data }: NodeProps<Node<AgentNodeData>>) {
-  const { config, state, colorIdx, previewLines, projectPath, workspaceId, onRun, onPause, onStop, onRetry, onEdit, onRemove, onMessage, onApprove, onShowLog, onShowMemory, onShowInbox, onOpenTerminal, onSwitchSession, onSaveAsTemplate, mascotTheme, bellOn = false, onToggleBell, inboxPending = 0, inboxFailed = 0 } = data;
+  const { config, state, colorIdx, previewLines, projectPath, workspaceId, onRun, onPause, onResume, onStop, onRetry, onEdit, onRemove, onMessage, onApprove, onShowLog, onShowMemory, onShowInbox, onOpenTerminal, onSwitchSession, onSaveAsTemplate, mascotTheme, bellOn = false, onToggleBell, inboxPending = 0, inboxFailed = 0 } = data;
   const c = COLORS[colorIdx % COLORS.length];
   const smithStatus = state?.smithStatus || 'down';
   const taskStatus = state?.taskStatus || 'idle';
@@ -3426,10 +3428,20 @@ function AgentFlowNode({ data }: NodeProps<Node<AgentNodeData>>) {
           </>
         )}
         {/* Message button — send instructions to agent */}
-        {smithStatus === 'active' && taskStatus !== 'running' && (
+        {smithStatus === 'active' && taskStatus !== 'running' && !state?.paused && (
           <button onPointerDown={e => e.stopPropagation()} onClick={e => { e.stopPropagation(); onMessage(); }}
             className="text-[9px] px-1.5 py-0.5 rounded bg-blue-600/20 text-blue-400 hover:bg-blue-600/30">💬 Message</button>
         )}
+        {/* Pause / Resume — icon-only so it doesn't widen the card */}
+        {smithStatus !== 'down' && config.type !== 'input' && (
+          <button onPointerDown={e => e.stopPropagation()}
+            onClick={e => { e.stopPropagation(); state?.paused ? onResume() : onPause(); }}
+            className={`text-[9px] px-1 ${state?.paused ? 'text-orange-400 hover:text-orange-300' : 'text-gray-600 hover:text-orange-400'}`}
+            title={state?.paused
+              ? 'Paused — click to resume bus pickups and watch alerts'
+              : 'Pause — drop new bus messages and watch alerts as failed (in-flight task continues)'}
+          >{state?.paused ? '▶' : '⏸'}</button>
+        )}
         <div className="flex-1" />
         <span className="flex items-center">
             <button onPointerDown={e => e.stopPropagation()}
@@ -3733,6 +3745,7 @@ function WorkspaceViewInner({ projectPath, projectName, onClose }: {
               wsApi(workspaceId!, 'run', { agentId: agent.id });
             },
             onPause: () => wsApi(workspaceId!, 'pause', { agentId: agent.id }),
+            onResume: () => wsApi(workspaceId!, 'resume', { agentId: agent.id }),
             onStop: () => wsApi(workspaceId!, 'stop', { agentId: agent.id }),
             mascotTheme,
             bellOn: bellAgents.has(agent.id),

package/lib/help-docs/11-workspace.md

@@ -414,7 +414,7 @@ Each smith can display an animated companion character next to its node.
 | **Stop Daemon** | Stop all smiths, kill workers. Preserves user's terminal conversation context (no `/clear` is sent). Tmux sessions attached to by a user are kept alive. |
 | **Run All** | Trigger all runnable agents once |
 | **Run** | Trigger specific agent |
-| **Pause/Resume** | Pause/resume message consumption for one agent |
+| **Pause/Resume** | Pause stops new bus pickups, drops queued + incoming messages to `failed`, and suppresses watch-alert dispatch. In-flight task continues. Resume re-enables. The pause flag is transient — daemon stop/start or process restart clears it. UI: ⏸ / ▶ icon on the smith card. |
 | **Mark Done/Failed/Idle** | Manually set task status |
 | **Retry** | Re-run a failed agent from checkpoint |
 | **Open Terminal** | Enter manual mode with tmux session |
@@ -592,6 +592,7 @@ Use this exact JSON structure when calling `POST /api/workspace/<id>/agents` wit
 
 - `action` values: `log` | `analyze` | `approve` | `send_message`
 - `sendTo` is required only when `action: "send_message"`
+- `agent_status` target is event-driven — orchestrator stamps a transition timestamp on every real `taskStatus` change (idempotent re-emits are deduped). The watch tick compares timestamps and only fires when the target has settled to a non-busy state (not `running`/`starting`) and matches `pattern`. Does not depend on polling, so sub-tick task transitions are caught reliably. Pattern matches the **final** state only — intermediate states during the interval window don't affect matching.
 
 ## Complete Recipes
 

package/lib/workspace/orchestrator.ts

@@ -39,7 +39,7 @@ import {
   loadMemory, saveMemory, createMemory, formatMemoryForPrompt,
   addObservation, addSessionSummary, parseStepToObservations, buildSessionSummary,
 } from './smith-memory';
-import { getFixedSession } from '../project-sessions';
+import { getFixedSession, setFixedSession } from '../project-sessions';
 
 // ─── Workspace Topology Cache ────────────────────────────
 
@@ -116,12 +116,29 @@ export class WorkspaceOrchestrator extends EventEmitter {
       if (event.type === 'log' && event.agentId && event.entry) {
         appendAgentLog(this.workspaceId, event.agentId, event.entry).catch(() => {});
       }
+      // Stamp taskStatus transitions. Idempotent re-emits of the same value
+      // don't bump the timestamp — agent_status watches rely on this to detect
+      // real transitions without polling.
+      if (event.type === 'task_status' && event.agentId && event.taskStatus) {
+        const entry = this.agents.get(event.agentId);
+        if (entry && entry.state.lastTaskStatus !== event.taskStatus) {
+          const prev = entry.state.lastTaskStatus;
+          entry.state.lastTaskStatus = event.taskStatus;
+          entry.state.taskStatusChangedAt = Date.now();
+          console.log(`[task_status] ${entry.config.label}: ${prev || '(none)'} → ${event.taskStatus} @ ${entry.state.taskStatusChangedAt}`);
+        }
+      }
     });
     // Handle watch events
     this.watchManager.on('watch_alert', (event) => {
+      const alertEntry = this.agents.get(event.agentId);
+      // Paused source smith — observation continues but no dispatch.
+      if (alertEntry?.state.paused) {
+        console.log(`[watch] ${alertEntry.config.label}: paused — alert dropped`);
+        return;
+      }
       this.emit('event', event);
       // Push alert to agent history so Log panel shows it
-      const alertEntry = this.agents.get(event.agentId);
       if (alertEntry && event.entry) {
         alertEntry.state.history.push(event.entry);
         this.emit('event', { type: 'log', agentId: event.agentId, entry: event.entry } as any);
@@ -266,6 +283,21 @@ export class WorkspaceOrchestrator extends EventEmitter {
     return null;
   }
 
+  /** Resolve the primary smith's fixed session for this project. If none is bound
+   *  yet, auto-bind to the latest existing claude session so the terminal picker
+   *  can offer "Current Session" instead of forcing the user into a fresh shell. */
+  resolvePrimaryFixedSession(): string | null {
+    const existing = getFixedSession(this.projectPath);
+    if (existing) return existing;
+    const primary = this.getPrimaryAgent();
+    if (!primary) return null;
+    const latest = this.getLatestSessionId(primary.config.workDir);
+    if (!latest) return null;
+    setFixedSession(this.projectPath, latest);
+    console.log(`[workspace] primary auto-bound to existing session ${latest} for ${this.projectPath}`);
+    return latest;
+  }
+
   addAgent(config: WorkspaceAgentConfig): void {
     const conflict = this.validateOutputs(config);
     if (conflict) throw new Error(conflict);
@@ -440,7 +472,7 @@ export class WorkspaceOrchestrator extends EventEmitter {
       const workerState = entry.worker?.getState();
       // Merge: worker state for task/smith, entry.state for mode (orchestrator controls mode)
       result[id] = workerState
-        ? { ...workerState, taskStatus: entry.state.taskStatus, tmuxSession: entry.state.tmuxSession, currentMessageId: entry.state.currentMessageId }
+        ? { ...workerState, taskStatus: entry.state.taskStatus, tmuxSession: entry.state.tmuxSession, currentMessageId: entry.state.currentMessageId, paused: entry.state.paused }
         : entry.state;
     }
     return result;
@@ -930,6 +962,9 @@ export class WorkspaceOrchestrator extends EventEmitter {
     // Clean up stale state from previous run
     this.bus.markAllRunningAsFailed();
 
+    // Paused is transient — clear on every daemon start so any leftover flag goes away.
+    for (const entry of this.agents.values()) entry.state.paused = false;
+
     // Install forge skills globally (once per daemon start)
     try {
       installForgeSkills(this.projectPath, this.workspaceId, '', Number(process.env.PORT) || 8403);
@@ -1167,6 +1202,9 @@ export class WorkspaceOrchestrator extends EventEmitter {
     for (const [id, entry] of this.agents) {
       if (entry.config.type === 'input') continue;
 
+      // 0. Clear transient paused flag — daemon stop should always reset it.
+      entry.state.paused = false;
+
       // 1. Stop message loop
       this.stopMessageLoop(id);
 
@@ -1633,16 +1671,40 @@ export class WorkspaceOrchestrator extends EventEmitter {
     return this.daemonActive;
   }
 
-  /** Pause a running agent */
+  /** Pause a smith — drop pending/incoming bus messages as failed, suppress watch alerts.
+   *  In-flight task continues. Resume does NOT replay dropped messages.
+   *  Transient: any daemon stop/start or process restart clears the flag. */
   pauseAgent(agentId: string): void {
     const entry = this.agents.get(agentId);
-    entry?.worker?.pause();
+    if (!entry) return;
+    entry.state.paused = true;
+    entry.worker?.pause();
+
+    // Drain inbox: anything queued for this smith → failed (visible in inbox).
+    let drained = 0;
+    for (const m of this.bus.getLog()) {
+      if (m.to !== agentId || m.type === 'ack') continue;
+      if (m.status === 'pending' || m.status === 'pending_approval') {
+        m.status = 'failed' as any;
+        drained++;
+        this.emit('event', { type: 'bus_message_status', messageId: m.id, status: 'failed' } as any);
+      }
+    }
+
+    this.emit('event', { type: 'task_status', agentId, taskStatus: entry.state.taskStatus } as any);
+    this.emitAgentsChanged();
+    console.log(`[workspace] ${entry.config.label}: paused${drained ? ` (${drained} pending message(s) dropped to failed)` : ''}`);
   }
 
-  /** Resume a paused agent */
+  /** Resume a paused smith — clear flag, re-enable bus pickup and watch dispatch. */
   resumeAgent(agentId: string): void {
     const entry = this.agents.get(agentId);
-    entry?.worker?.resume();
+    if (!entry) return;
+    entry.state.paused = false;
+    entry.worker?.resume();
+    this.emit('event', { type: 'task_status', agentId, taskStatus: entry.state.taskStatus } as any);
+    this.emitAgentsChanged();
+    console.log(`[workspace] ${entry.config.label}: resumed`);
   }
 
   /** Stop a running agent */
@@ -2902,6 +2964,14 @@ Silently ingest this context. Do NOT respond — await an actual task.`;
     // ── Store message in agent history ──
     target.state.history.push(logEntry);
 
+    // ── Paused smith → drop as failed; user retries/deletes from inbox. ──
+    if (target.state.paused) {
+      msg.status = 'failed' as any;
+      this.emit('event', { type: 'bus_message_status', messageId: msg.id, status: 'failed' } as any);
+      console.log(`[bus] ${target.config.label}: paused — ${action} dropped to failed`);
+      return;
+    }
+
     // ── requiresApproval → set pending_approval on arrival ──
     if (target.config.requiresApproval) {
       msg.status = 'pending_approval';
@@ -2933,6 +3003,9 @@ Silently ingest this context. Do NOT respond — await an actual task.`;
       // (loop stays alive so it works when smith comes back)
       if (entry.state.smithStatus !== 'active') return;
 
+      // Paused smiths refuse new bus pickups; loop stays alive for resume.
+      if (entry.state.paused) return;
+
       // Skip if already busy
       if (entry.state.taskStatus === 'running') return;
 

package/lib/workspace/persistence.ts

@@ -53,6 +53,9 @@ export async function saveWorkspace(state: WorkspaceState): Promise<void> {
         ...s,
         history: [],
         logFile: agentLogFile(state.id, id),
+        paused: undefined,                // transient — never persisted
+        taskStatusChangedAt: undefined,   // transient
+        lastTaskStatus: undefined,        // transient
       }])
     ),
     updatedAt: Date.now(),
@@ -90,6 +93,9 @@ export function saveWorkspaceSync(state: WorkspaceState): void {
         ...s,
         history: [],
         logFile: agentLogFile(state.id, id),
+        paused: undefined,                // transient — never persisted
+        taskStatusChangedAt: undefined,   // transient
+        lastTaskStatus: undefined,        // transient
       }])
     ),
     updatedAt: Date.now(),
@@ -160,6 +166,16 @@ export function loadWorkspace(workspaceId: string): WorkspaceState | null {
       if (agentState.taskStatus === 'running') {
         agentState.taskStatus = 'idle';
       }
+
+      // Defensive: paused is transient. Force false on load in case any
+      // older state.json still has it persisted.
+      agentState.paused = false;
+
+      // Init the agent_status watch fields. Setting changedAt to now() means
+      // any transitions that happen after load advance the timestamp; watchers
+      // record this baseline at their first tick and won't spuriously fire.
+      agentState.taskStatusChangedAt = Date.now();
+      agentState.lastTaskStatus = agentState.taskStatus;
     }
 
     // Migrate Input nodes: content → entries

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/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.43",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {