@dotdrelle/wiki-manager 0.14.13 → 0.14.20

package/src/shell/useSession.ts

@@ -321,6 +321,52 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
       ? lastVisiblePlan.map((step) => ({ ...step }))
       : current;
   });
+  const runSummary = createMemo(() => {
+    version();
+    const workflow = runtimeState()?.workflow;
+    const tasks = Array.isArray(workflow?.nodes)
+      ? workflow.nodes.filter((node: any) => node.type === 'task')
+      : [];
+    if (tasks.length === 0) return null;
+
+    const graphNodes = Array.isArray(workflow?.graph?.nodes) ? workflow.graph.nodes : [];
+    const graphEdges = Array.isArray(workflow?.graph?.edges) ? workflow.graph.edges : [];
+    const agents = new Set<string>();
+    for (const task of tasks) {
+      if (task.executor) agents.add(String(task.executor));
+      const assignmentIds = graphEdges
+        .filter((edge: any) => edge.type === 'assigned_to' && edge.from === task.id)
+        .map((edge: any) => edge.to);
+      for (const assignmentId of assignmentIds) {
+        graphEdges
+          .filter((edge: any) => edge.type === 'uses_agent' && edge.from === assignmentId)
+          .forEach((edge: any) => agents.add(String(edge.to).replace(/^agent:/, '')));
+      }
+    }
+
+    const activeParallel = tasks.filter((task: any) => String(task.status) === 'running').length;
+    const groupConcurrency = graphNodes
+      .filter((node: any) => node.type === 'task_group')
+      .map((node: any) => Number(node.raw?.recommendedConcurrency))
+      .filter((value: number) => Number.isFinite(value) && value > 0);
+    // Authoritative resolved concurrency published by the runtime; fall back to
+    // the plan-derived value for replayed/historical runs.
+    const resolved = runtimeState()?.concurrency;
+    const maxParallel = Number.isFinite(Number(resolved?.limit))
+      ? Number(resolved.limit)
+      : Math.max(1, activeParallel, ...groupConcurrency);
+    const done = tasks.filter((task: any) => String(task.status) === 'done').length;
+    const usage = workflow?.usage ?? {};
+    const tokens = (known: unknown, value: unknown) =>
+      known ? new Intl.NumberFormat().format(Number(value) || 0) : '—';
+
+    return [
+      `${agents.size} agent${agents.size === 1 ? '' : 's'}`,
+      `parallel ${activeParallel}/×${maxParallel}${resolved?.cappedByCeiling ? ' (ceiling)' : ''}`,
+      `${done}/${tasks.length} tasks`,
+      `${tokens(usage.inputKnown, usage.inputTokens)} in · ${tokens(usage.outputKnown, usage.outputTokens)} out`,
+    ].join(' · ');
+  });
   const visibleLogs = createMemo(() => {
     version();
     const runtimeLogs = runtimeState()?.logs;
@@ -329,6 +375,11 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     const tagged = filterRuntimeLogs(runtimeLogs.map((line: any) => `runtime ${String(line)}`), filter);
     return [...logs(), ...tagged];
   });
+  const pendingApprovals = createMemo(() => {
+    version();
+    return (Array.isArray(runtimeState()?.approvals) ? runtimeState().approvals : [])
+      .filter((approval: any) => approval.status === 'pending_approval');
+  });
 
   // Index-aligned with each workspace's runtimeConversation array — not just
   // a length count. The server sometimes finalizes a streaming placeholder
@@ -379,16 +430,23 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
         continue;
       }
       if (role === 'user') {
-        // The user's own message was already pushed optimistically (see
-        // useAgent.ts) and marked _pending — confirm that entry instead of
-        // adding a second copy. No matching pending entry (e.g. history
-        // restored after a fresh reconnect) falls through to a normal push.
+        // The user's own message was already pushed optimistically — either
+        // marked _pending (web / runtime-submit path, useAgent.ts) OR as a plain
+        // entry by the interactive agent turn (repl.js runAgentTurn) that then
+        // delegated. Adopt whichever already exists instead of appending a
+        // second identical copy (the delegation seeds the run with the same
+        // objective, which comes back through this merge).
         const pendingIndex = target.findIndex((entry: any) => entry._pending && entry.role === 'user' && entry.content === content);
         if (pendingIndex !== -1) {
           delete target[pendingIndex]._pending;
           backed.push(target[pendingIndex]);
           continue;
         }
+        const localIndex = target.findIndex((entry: any) => entry.role === 'user' && entry.content === content && !backed.includes(entry));
+        if (localIndex !== -1) {
+          backed.push(target[localIndex]);
+          continue;
+        }
       }
       const entry = { role, content };
       target.push(entry);
@@ -397,19 +455,37 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
   }
 
   function syncRuntimeState() {
-    void fetchRuntimeState({ url: props.runtime.url, workspace: (session as any).workspace ?? null })
+    const workspace = (session as any).workspace ?? null;
+    const workspaceKey = workspace ?? '__global__';
+    if (runtimeSyncInFlight.has(workspaceKey)) return;
+    runtimeSyncInFlight.add(workspaceKey);
+    void fetchRuntimeState({ url: props.runtime.url, workspace })
       .then((state) => {
+        if (((session as any).workspace ?? null) !== workspace) return;
         const displayState = sanitizeRuntimeStateForDisplay(state);
         setRuntimeState(displayState);
+        // The per-job "Job terminé" lines and the canned plan summary are gone:
+        // the runtime now emits ONE natural-language Donna message at completion
+        // (see announceRunOutcome in runner.js), which arrives through the
+        // conversation merge below. Detect that the chat grew to keep the
+        // welcome-hidden / scroll-to-latest behavior.
+        const beforeLength = conversationMessages(session).length;
         mergeRuntimeConversation(displayState);
+        if (conversationMessages(session).length > beforeLength) {
+          setShowWelcome(false);
+          setConversationScroll(0);
+        }
         setRuntimeStatus('connected');
         refresh();
       })
       .catch(() => {
+        if (((session as any).workspace ?? null) !== workspace) return;
         setRuntimeStatus('disconnected');
         refresh();
-      });
+      })
+      .finally(() => { runtimeSyncInFlight.delete(workspaceKey); });
   }
+  const runtimeSyncInFlight = new Set<string>();
   let runtimeStreamAbort: AbortController | null = null;
   let runtimeSyncDebounce: ReturnType<typeof setTimeout> | null = null;
   let runtimeReconnectTimer: ReturnType<typeof setTimeout> | null = null;
@@ -446,6 +522,13 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     void subscribeRuntimeEvents();
   }
 
+  // Safety net only — the SSE stream (subscribeRuntimeEvents) is the primary
+  // sync path and already debounces on every agent_event. This just catches
+  // a missed/dropped event, so it can poll far less often than that.
+  const runtimeCompletionWatchdog = setInterval(() => {
+    if (props.runtime?.url && runtimeRunStatus() === 'running') syncRuntimeState();
+  }, 10000);
+
   let currentRuntimeWorkspace = (session as any).workspace ?? null;
   function resyncRuntimeWorkspaceIfChanged() {
     const workspace = (session as any).workspace ?? null;
@@ -466,6 +549,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     runtimeStreamAbort?.abort();
     if (runtimeSyncDebounce) clearTimeout(runtimeSyncDebounce);
     if (runtimeReconnectTimer) clearTimeout(runtimeReconnectTimer);
+    clearInterval(runtimeCompletionWatchdog);
   });
 
   const activityPollTimer = setInterval(() => {
@@ -690,6 +774,8 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     toggleRightTab,
     selectRightTab,
     plan,
+    runSummary,
+    pendingApprovals,
     conversationScroll,
     scrollConversation,
     conversationBusy,

package/wiki-workspace

@@ -95,6 +95,7 @@ Commands:
   agents down                       Stop all external agents
   agents logs [args...]             Follow external agent logs
   agents pull                       Pull latest external agent images
+  agents refresh                    Update only external agents currently running
   agents status                     Check reachability of configured MCP endpoints
 
   runtime up                        Start the single host agent-runtime on Node.js 22
@@ -276,6 +277,10 @@ agents_compose() {
       [[ $# -eq 0 ]] || die "agents pull does not take arguments"
       _agents_dc pull
       ;;
+    refresh)
+      [[ $# -eq 0 ]] || die "agents refresh does not take arguments"
+      refresh_running_services 'No running external agent containers to refresh' 'Refreshed running agents: %s' _agents_dc
+      ;;
     status)
       [[ $# -eq 0 ]] || die "agents status does not take arguments"
       if [[ ! -f "$MANAGER_ENDPOINTS_FILE" ]]; then
@@ -751,10 +756,30 @@ read_lines_into_array() {
   eval "$array_name=()"
   local line
   while IFS= read -r line; do
+    [[ -n "${line//[[:space:]]/}" ]] || continue
     eval "$array_name+=(\"\$line\")"
   done < <("$@")
 }
 
+# Shared by the "agents refresh" and per-workspace "refresh" subcommands:
+# pull and recreate only the compose services already running, skipping the
+# rest. "$@" is the compose invocation (e.g. `_agents_dc` or
+# `compose_for_workspace "$workspace"`) to run ps/pull/up through.
+refresh_running_services() {
+  local no_running_msg="$1"
+  local refreshed_msg_fmt="$2"
+  shift 2
+  local running_services=()
+  read_lines_into_array running_services "$@" ps --status running --services
+  if [[ ${#running_services[@]} -eq 0 ]]; then
+    printf '%s\n' "$no_running_msg"
+    return
+  fi
+  "$@" pull "${running_services[@]}"
+  "$@" up -d "${running_services[@]}"
+  printf "$refreshed_msg_fmt\n" "${running_services[*]}"
+}
+
 cacert_compose_args() {
   local compose_file="$1"
   local override_name="$2"
@@ -1074,6 +1099,9 @@ main() {
     down)
       compose_for_workspace "$workspace" down
       ;;
+    refresh)
+      refresh_running_services "No running workspace containers to refresh: $workspace" "Refreshed running workspace containers: $workspace (%s)" compose_for_workspace "$workspace"
+      ;;
     logs)
       local log_args=()
       read_lines_into_array log_args logs_args "$@"