@dotdrelle/wiki-manager 0.7.3 → 0.8.2

package/src/cli/wiki-manager.js

@@ -1,4 +1,3 @@
-import { randomUUID } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
@@ -6,7 +5,7 @@ import { fileURLToPath } from 'node:url';
 import { loadManagerEnv } from '../core/env.js';
 loadManagerEnv();
 import { createAgentGraph } from '../agent/graph.js';
-import { handleSlashCommand, printHelp, printVersion } from '../commands/slash.js';
+import { handleSlashCommand, printHelp, printVersion, refreshMcpRuntimeStatus } from '../commands/slash.js';
 import { runShell } from '../shell/repl.js';
 import { runChecks } from '../core/startupCheck.js';
 import { callMcpTool, formatMcpToolResult } from '../core/mcp.js';
@@ -20,7 +19,7 @@ import { runAgentTurn, runAgenticLoop } from '../core/agentLoop.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const packageJsonPath = resolve(__dirname, '../../package.json');
 const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-const SHELL_COMMANDS = ['help', 'version', 'exit', 'workspace', 'new', 'use', 'config', 'status', 'services', 'start', 'stop', 'logs', 'mcp', 'wiki', 'skills', 'clear', 'chat', 'agent'];
+const SHELL_COMMANDS = ['help', 'version', 'exit', 'workspace', 'new', 'use', 'config', 'status', 'services', 'start', 'stop', 'logs', 'mcp', 'wiki', 'skills', 'clear', 'chat', 'agent', 'approve'];
 
 function valueAfter(argv, flag) {
   const index = argv.indexOf(flag);
@@ -286,12 +285,13 @@ async function runRuntime(argv, agent) {
     ].join('\n'));
     return;
   }
-  const { defaultRuntimeStateDir, openRuntimeStore } = await import('../runtime/store.js');
+  const { defaultRuntimeStateDir, openRuntimeStore, RECOVERABLE_QUEUE_STATUSES } = await import('../runtime/store.js');
   const { startRuntimeServer } = await import('../runtime/server.js');
   const { emitRuntimeLog, startActivitySupervisor } = await import('../runtime/supervisor.js');
   const { resolveRuntimeAuthToken } = await import('../runtime/auth.js');
   const { createSqliteQueueStore } = await import('../runtime/queueStore.js');
-  const { runRuntimeAgenticLoop } = await import('../runtime/runner.js');
+  const { createApprovalManager } = await import('../runtime/approvals.js');
+  const { runRuntimeAgenticWorkflow } = await import('../runtime/runner.js');
 
   const host = valueAfter(argv, '--host') ?? process.env.WIKI_MANAGER_RUNTIME_HOST ?? '0.0.0.0';
   const port = Number(valueAfter(argv, '--port') ?? process.env.WIKI_MANAGER_RUNTIME_PORT ?? 7788);
@@ -302,45 +302,267 @@ async function runRuntime(argv, agent) {
     throw new Error(`Invalid runtime port: ${port}`);
   }
 
-  const session = createSession();
-  session.headless = true;
-  session.chatMode = false;
-  session.packageJson = packageJson;
-
   const store = openRuntimeStore({ stateDir });
-  store.hydrateSession(session);
-  session.queueStore = createSqliteQueueStore(store, session);
-
   let serverHandle = null;
-  session._onAgentEvent = (event) => {
-    store.persistEvent(event);
-    serverHandle?.publish(event);
-  };
-  session._onRuntimeError = (err) => {
-    const message = err instanceof Error ? err.message : String(err);
-    dispatchAgentEvent(session, createAgentEvent('run_error', {
-      origin: 'runtime',
-      payload: { message },
-    }));
-  };
+  const contexts = new Map();
+
+  async function getWorkspaceContext(workspaceName = null) {
+    const requestedWorkspace = workspaceName ? String(workspaceName).trim() : null;
+    const key = requestedWorkspace ?? '__default__';
+    if (contexts.has(key)) return contexts.get(key);
+
+    const pending = (async () => {
+      const session = createSession();
+      session.headless = true;
+      session.chatMode = false;
+      session.packageJson = packageJson;
+
+      if (requestedWorkspace) {
+        const result = await handleSlashCommand(`/use ${requestedWorkspace}`, { packageJson, session });
+        if (!session.workspacePath) throw new Error(result.output || `Workspace not loaded: ${requestedWorkspace}`);
+      }
+      const workspace = session.workspace ?? requestedWorkspace ?? null;
+      store.hydrateSession(session, { workspace });
+      session.queueStore = createSqliteQueueStore(store, session, { workspace });
+
+      const context = {
+        workspace,
+        session,
+        supervisor: null,
+        running: false,
+        currentAbortController: null,
+        approvalManager: null,
+      };
+      session._onAgentEvent = (event) => {
+        store.persistEvent(event);
+        serverHandle?.publish(event);
+      };
+      session._onRuntimeError = (err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        dispatchAgentEvent(session, createAgentEvent('run_error', {
+          origin: 'runtime',
+          payload: { message, workspace },
+        }));
+      };
+      context.approvalManager = createApprovalManager(session, {
+        defaultTimeoutMs: Number.isFinite(Number(process.env.WIKI_MANAGER_APPROVAL_TIMEOUT_MS))
+          ? Math.max(1, Number(process.env.WIKI_MANAGER_APPROVAL_TIMEOUT_MS))
+          : undefined,
+      });
+      session._requestApproval = (request) => context.approvalManager.requestApproval(request);
+      context.supervisor = startActivitySupervisor(session);
+      contexts.set(key, context);
+      if (workspace && workspace !== key) contexts.set(workspace, context);
+      return context;
+    })();
+    contexts.set(key, pending);
+    pending.catch(() => {
+      if (contexts.get(key) === pending) contexts.delete(key);
+    });
+    return pending;
+  }
+
+  function recoveryMcpGaps(context) {
+    const gaps = [];
+    const session = context.session;
+    for (const activity of sessionActivities(session)) {
+      if (activity.terminal || !activity.poll?.server) continue;
+      const endpoint = session.mcp?.[activity.poll.server];
+      if (endpoint?.status !== 'connected') gaps.push(activity.poll.server);
+    }
+    for (const item of session.queueStore?.list?.() ?? []) {
+      const status = String(item.status ?? '').toLowerCase();
+      if (!RECOVERABLE_QUEUE_STATUSES.includes(status)) continue;
+      const endpoint = session.mcp?.[item.server ?? 'production'];
+      if (endpoint?.status !== 'connected') gaps.push(item.server ?? 'production');
+    }
+    return [...new Set(gaps)];
+  }
+
+  function activeNonTerminalActivities(session) {
+    return sessionActivities(session).filter((activity) => !activity.terminal);
+  }
+
+  function activePollingActivities(session) {
+    return activeNonTerminalActivities(session).filter((activity) => activity.poll);
+  }
+
+  function buildRecoveryPrompt(run, session) {
+    const conversation = session.agentProjection?.conversation ?? [];
+    const recentConversation = conversation
+      .slice(-8)
+      .map((message) => `${message.role}: ${message.content}`)
+      .join('\n');
+    return [
+      'Resume an interrupted runtime run.',
+      '',
+      'Original task:',
+      run.input ?? '(unknown)',
+      '',
+      session.headlessPlan ? `Current plan:\n${formatPlanStatus(session.headlessPlan)}` : null,
+      recentConversation ? `Recent conversation:\n${recentConversation}` : null,
+      '',
+      'Continue from the current plan state. Start only the next pending step.',
+      'If the work is already complete, provide a concise final summary.',
+    ].filter(Boolean).join('\n');
+  }
+
+  function startRecoveredAgenticRun(context, run) {
+    if (context.running) return false;
+    const session = context.session;
+    const supervisor = context.supervisor;
+    const runId = run.id;
+    const input = buildRecoveryPrompt(run, session);
+    context.running = true;
+    context.currentAbortController = new AbortController();
+    session._currentRunIdentity = {
+      runId,
+      turnId: `${runId}:resume-0`,
+      workspace: context.workspace,
+    };
+    session._abortSignal = context.currentAbortController.signal;
+    supervisor?.setRunSignal(context.currentAbortController.signal);
+    session._onStep = (message) => emitRuntimeLog(session, message);
+    emitRuntimeLog(session, `runtime: resuming interrupted run ${runId}`);
+
+    runRuntimeAgenticWorkflow(agent, session, run.input ?? input, {
+      initialInput: input,
+      signal: context.currentAbortController.signal,
+      timeoutMs: 3600 * 1000,
+      maxTurns: 20,
+      runId,
+      pollBusy: supervisor?.pollBusy,
+    })
+      .catch((err) => {
+        if (err?.name === 'AbortError') {
+          dispatchAgentEvent(session, createAgentEvent('run_cancelled', {
+            origin: 'runtime',
+            runId,
+            payload: { runId, message: 'Recovered runtime run cancelled.' },
+          }));
+          return;
+        }
+        dispatchAgentEvent(session, createAgentEvent('run_error', {
+          origin: 'runtime',
+          runId,
+          payload: {
+            runId,
+            message: err instanceof Error ? err.message : String(err),
+          },
+        }));
+      })
+      .finally(() => {
+        context.running = false;
+        context.currentAbortController = null;
+        supervisor?.setRunSignal(null);
+        delete session._abortSignal;
+        delete session._onStep;
+        delete session._currentRunIdentity;
+      });
+
+    return true;
+  }
+
+  async function recoverWorkspace(workspace, { manual = false } = {}) {
+    try {
+      const context = await getWorkspaceContext(workspace);
+      await refreshMcpRuntimeStatus(context.session);
+      const gaps = recoveryMcpGaps(context);
+      if (gaps.length > 0) {
+        const interrupted = store.interruptRuns({ workspace: context.workspace });
+        return {
+          workspace: context.workspace ?? workspace ?? null,
+          resumed: false,
+          interrupted,
+          reason: `MCP unavailable: ${gaps.join(', ')}`,
+        };
+      }
+      const recoverableRuns = store.listRecoverableRuns({ workspace: context.workspace });
+      const runningRun = recoverableRuns.find((run) => run.status === 'running');
+      const activeActivities = activeNonTerminalActivities(context.session);
+      const pollingActivities = activePollingActivities(context.session);
+      if (runningRun && activeActivities.length === 0) {
+        if (!runningRun.input) {
+          const interrupted = store.interruptRuns({ workspace: context.workspace });
+          return {
+            workspace: context.workspace ?? workspace ?? null,
+            resumed: false,
+            interrupted,
+            reason: 'Missing original run input.',
+          };
+        }
+        const started = startRecoveredAgenticRun(context, runningRun);
+        return {
+          workspace: context.workspace ?? workspace ?? null,
+          resumed: started,
+          interrupted: 0,
+          mode: 'agentic_loop',
+        };
+      }
+      if (runningRun && runningRun.input && pollingActivities.length > 0) {
+        context.session._onActivitiesTerminal = () => {
+          startRecoveredAgenticRun(context, runningRun);
+        };
+        emitRuntimeLog(context.session, `runtime: recovery watching ${pollingActivities.length} active activity(s)`);
+        return {
+          workspace: context.workspace ?? workspace ?? null,
+          resumed: true,
+          interrupted: 0,
+          mode: 'activity_poll_then_resume',
+        };
+      }
+      emitRuntimeLog(context.session, manual ? 'runtime: manual resume completed' : 'runtime: recovery completed');
+      return {
+        workspace: context.workspace ?? workspace ?? null,
+        resumed: true,
+        interrupted: 0,
+        mode: pollingActivities.length > 0 ? 'activity_poll' : 'context',
+      };
+    } catch (err) {
+      const interrupted = store.interruptRuns({ workspace });
+      return {
+        workspace: workspace ?? null,
+        resumed: false,
+        interrupted,
+        reason: err instanceof Error ? err.message : String(err),
+      };
+    }
+  }
 
-  let supervisor = null;
+  async function recoverRuntime({ workspace = null, manual = false } = {}) {
+    const workspaces = workspace ? [workspace] : store.listRecoverableWorkspaces();
+    const results = await Promise.all(workspaces.map((item) => recoverWorkspace(item, { manual })));
+    return {
+      resumed: results.filter((result) => result.resumed).length,
+      interrupted: results.reduce((sum, result) => sum + Number(result.interrupted ?? 0), 0),
+      workspaces: results,
+    };
+  }
 
-  async function executeRun(body, { signal } = {}) {
+  async function executeRun(context, body, { signal } = {}) {
+    const session = context.session;
+    const supervisor = context.supervisor;
     const input = String(body.input ?? body.prompt ?? '').trim();
     const workspace = body.workspace ? String(body.workspace).trim() : null;
     const timeoutMs = (Number.isFinite(Number(body.timeout)) ? Math.max(1, Number(body.timeout)) : 3600) * 1000;
     const maxTurns = Number.isFinite(Number(body.maxTurns)) ? Math.max(1, Number(body.maxTurns)) : 20;
-    const runId = randomUUID();
+    const maxReplans = Number.isFinite(Number(body.replans)) ? Math.max(0, Math.floor(Number(body.replans))) : undefined;
+    const runId = String(body.runId);
     try {
       if (workspace && session.workspace !== workspace) {
         const result = await handleSlashCommand(`/use ${workspace}`, { packageJson, session });
         if (!session.workspacePath) throw new Error(result.output || `Workspace not loaded: ${workspace}`);
       }
+      context.workspace = session.workspace ?? workspace ?? context.workspace ?? null;
+      session._currentRunIdentity = {
+        runId,
+        turnId: `${runId}:turn-0`,
+        workspace: context.workspace,
+      };
       dispatchAgentEvent(session, createAgentEvent('run_started', {
         origin: 'runtime',
         runId,
-        payload: { input, workspace },
+        payload: { input, workspace: session._currentRunIdentity.workspace },
       }));
       dispatchAgentEvent(session, createAgentEvent('user_message', {
         origin: 'user',
@@ -348,35 +570,22 @@ async function runRuntime(argv, agent) {
         payload: { content: input },
       }));
       session._abortSignal = signal ?? null;
+      session._runApprovalRequired = body.requireApproval === true;
+      session._runApprovalResolved = false;
+      session._approvalTimeoutMs = Number.isFinite(Number(body.approvalTimeoutMs))
+        ? Math.max(1, Number(body.approvalTimeoutMs))
+        : undefined;
       supervisor?.setRunSignal(signal);
       session._onStep = (message) => emitRuntimeLog(session, message);
-      const result = await runRuntimeAgenticLoop(agent, session, input, {
+      await runRuntimeAgenticWorkflow(agent, session, input, {
         signal,
         timeoutMs,
         maxTurns,
         runId,
         pollBusy: supervisor?.pollBusy,
+        evaluate: body.evaluate !== false,
+        ...(maxReplans === undefined ? {} : { maxReplans }),
       });
-      if (!result.ok) {
-        dispatchAgentEvent(session, createAgentEvent('run_error', {
-          origin: 'runtime',
-          runId,
-          payload: {
-            runId,
-            message: result.timedOut
-              ? 'Runtime agentic loop timed out.'
-              : result.maxTurns
-                ? `Runtime agentic loop reached max turns (${maxTurns}).`
-                : 'Runtime agentic loop failed.',
-          },
-        }));
-        return;
-      }
-      dispatchAgentEvent(session, createAgentEvent('run_done', {
-        origin: 'runtime',
-        runId,
-        payload: { runId },
-      }));
     } catch (err) {
       if (err?.name === 'AbortError') {
         dispatchAgentEvent(session, createAgentEvent('run_cancelled', {
@@ -401,6 +610,10 @@ async function runRuntime(argv, agent) {
       supervisor?.setRunSignal(null);
       delete session._abortSignal;
       delete session._onStep;
+      delete session._currentRunIdentity;
+      delete session._runApprovalRequired;
+      delete session._runApprovalResolved;
+      delete session._approvalTimeoutMs;
     }
   }
 
@@ -408,19 +621,27 @@ async function runRuntime(argv, agent) {
     host,
     port,
     store,
-    session,
+    getContext: getWorkspaceContext,
     run: executeRun,
-    cancel: () => emitRuntimeLog(session, 'runtime: cancel requested'),
+    cancel: (context) => emitRuntimeLog(context.session, 'runtime: cancel requested'),
+    resume: ({ workspace }) => recoverRuntime({ workspace, manual: true }),
+    approve: async ({ workspace, runId, itemId, approvalId }) => {
+      const context = await getWorkspaceContext(workspace);
+      return context.approvalManager?.approve({ runId, itemId, approvalId }) ?? { approved: false };
+    },
     token: auth.token,
   });
-  supervisor = startActivitySupervisor(session);
+  const recovery = await recoverRuntime();
 
   console.log(`wiki-manager runtime listening on http://${host}:${port}`);
   console.log(`runtime state: ${store.dbPath}`);
+  if (recovery.resumed > 0 || recovery.interrupted > 0) {
+    console.log(`runtime recovery: resumed=${recovery.resumed} interrupted=${recovery.interrupted}`);
+  }
   if (auth.tokenPath) console.log(`runtime token: ${auth.tokenPath}`);
 
   const shutdown = async () => {
-    supervisor?.stop();
+    await Promise.all([...new Set(contexts.values())].map(async (v) => { (await v).supervisor?.stop(); }));
     await serverHandle.close();
     store.close();
     process.exit(0);

package/src/commands/slash.js

@@ -490,7 +490,7 @@ function publishDocumentActivity(session, activity) {
   return publishPayloadActivity(session, { _activity: activity }, { server: 'documents', tool: 'documents_convert_to_markdown' });
 }
 
-async function refreshMcpRuntimeStatus(session) {
+export async function refreshMcpRuntimeStatus(session) {
   session.mcp = buildMcpStatus(session);
   if (!session.workspacePath) return null;
   try {

package/src/core/agentEvents.js

@@ -1,11 +1,18 @@
 import { normalizeActivity } from './activity.js';
-import { syncActivitiesToPlan } from './plan.js';
+import { attachActivityToExistingPlan, syncActivitiesToPlan } from './plan.js';
 
 const SESSION_PROJECTION_EVENTS = new Set([
   'run_started',
   'plan_set',
   'plan_step_updated',
   'activity_upserted',
+  'run_evaluated',
+  'run_replanned',
+  'run_pending_approval',
+  'run_approved',
+  'tool_pending_approval',
+  'tool_approved',
+  'run_done',
   'run_error',
   'run_cancelled',
   'runtime_log',
@@ -19,9 +26,16 @@ const PLAN_MUTATING_EVENTS = new Set([
   'plan_set',
   'plan_step_updated',
   'activity_upserted',
+  'run_done',
 ]);
 
-export function createAgentEvent(type, { origin = 'system', payload = {}, runId = null, turnId = null } = {}) {
+export function createAgentEvent(type, {
+  origin = 'system',
+  payload = {},
+  runId = null,
+  turnId = null,
+  workspace = null,
+} = {}) {
   return {
     id: `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`,
     ts: new Date().toISOString(),
@@ -29,12 +43,16 @@ export function createAgentEvent(type, { origin = 'system', payload = {}, runId
     origin,
     runId,
     turnId,
+    workspace,
     payload,
   };
 }
 
 export function dispatchAgentEvent(session, event) {
-  const normalized = event.id && event.ts ? event : createAgentEvent(event.type, event);
+  const normalized = withSessionRunIdentity(
+    event.id && event.ts ? event : createAgentEvent(event.type, event),
+    session,
+  );
   const tracksPlan = PLAN_MUTATING_EVENTS.has(normalized.type);
   const previousPlan = tracksPlan ? JSON.stringify(session.headlessPlan ?? null) : null;
   session.agentEvents ??= [];
@@ -52,6 +70,17 @@ export function dispatchAgentEvent(session, event) {
   return normalized;
 }
 
+function withSessionRunIdentity(event, session) {
+  const identity = session?._currentRunIdentity;
+  if (!identity) return event;
+  return {
+    ...event,
+    runId: event.runId ?? identity.runId ?? null,
+    turnId: event.turnId ?? identity.turnId ?? null,
+    workspace: event.workspace ?? identity.workspace ?? null,
+  };
+}
+
 export function reduceAgentEvents(events = []) {
   const state = createProjectionState();
 
@@ -69,6 +98,9 @@ function createProjectionState() {
     plan: null,
     activities: {},
     logs: [],
+    evaluation: null,
+    replans: [],
+    approvals: [],
     summary: null,
     status: 'idle',
   };
@@ -81,6 +113,9 @@ function publicProjection(state) {
     plan: state.plan ? state.plan.map((step) => ({ ...step })) : null,
     activities: sortedActivities(state.activities).map((activity) => ({ ...activity })),
     logs: [...state.logs],
+    evaluation: state.evaluation ? { ...state.evaluation } : null,
+    replans: state.replans.map((replan) => ({ ...replan, plan: [...(replan.plan ?? [])] })),
+    approvals: state.approvals.map((approval) => ({ ...approval })),
     summary: state.summary,
     status: state.status,
   };
@@ -103,10 +138,13 @@ function applyEvent(state, event) {
   switch (event.type) {
     case 'run_started':
       state.status = 'running';
-      state.plan = null;
+      state.plan = defaultRunPlan();
       state.chain = [];
       state.activities = {};
       state.logs = [];
+      state.evaluation = null;
+      state.replans = [];
+      state.approvals = [];
       state.summary = null;
       return;
     case 'user_message':
@@ -144,8 +182,50 @@ function applyEvent(state, event) {
       state.summary = String(event.payload?.content ?? '');
       if (state.summary) state.conversation.push({ role: 'assistant', content: state.summary });
       return;
+    case 'run_evaluated':
+      state.evaluation = {
+        ok: event.payload?.ok === true,
+        reason: String(event.payload?.reason ?? ''),
+        suggestedAction: event.payload?.suggestedAction ?? null,
+        runId: event.runId ?? event.payload?.runId ?? null,
+      };
+      return;
+    case 'run_replanned':
+      state.replans.push({
+        reason: String(event.payload?.reason ?? ''),
+        plan: Array.isArray(event.payload?.plan) ? event.payload.plan.map(String) : [],
+        replansLeft: Number(event.payload?.replansLeft ?? 0),
+        runId: event.runId ?? event.payload?.runId ?? null,
+      });
+      return;
+    case 'run_pending_approval':
+    case 'tool_pending_approval':
+      upsertApproval(state, {
+        id: event.payload?.approvalId ?? event.payload?.runId ?? event.payload?.itemId ?? event.id,
+        scope: event.type === 'run_pending_approval' ? 'run' : 'tool',
+        status: 'pending_approval',
+        runId: event.runId ?? event.payload?.runId ?? null,
+        itemId: event.payload?.itemId ?? null,
+        reason: event.payload?.reason ?? null,
+        tool: event.payload?.tool ?? null,
+        plan: event.payload?.plan ?? null,
+        createdAt: event.ts,
+      });
+      return;
+    case 'run_approved':
+    case 'tool_approved':
+      upsertApproval(state, {
+        id: event.payload?.approvalId ?? event.payload?.runId ?? event.payload?.itemId ?? event.id,
+        scope: event.type === 'run_approved' ? 'run' : 'tool',
+        status: 'approved',
+        runId: event.runId ?? event.payload?.runId ?? null,
+        itemId: event.payload?.itemId ?? null,
+        approvedAt: event.ts,
+      });
+      return;
     case 'run_done':
       state.status = 'done';
+      finishPendingPlanSteps(state.plan);
       return;
     case 'run_cancelled':
       state.status = 'cancelled';
@@ -198,6 +278,26 @@ function finishToolCall(state, payload = {}) {
   if (!existing) state.chain.push(step);
 }
 
+function upsertApproval(state, next) {
+  const index = state.approvals.findIndex((approval) => approval.id === next.id);
+  if (index === -1) {
+    state.approvals.push(next);
+    return;
+  }
+  state.approvals[index] = {
+    ...state.approvals[index],
+    ...next,
+  };
+}
+
+function finishPendingPlanSteps(plan) {
+  for (const step of plan ?? []) {
+    if (step.status === 'running' || step.status === 'pending') {
+      step.status = 'done';
+    }
+  }
+}
+
 function upsertActivity(state, rawActivity) {
   const activity = normalizeActivity(rawActivity);
   if (!activity) return;
@@ -211,6 +311,10 @@ function upsertActivity(state, rawActivity) {
 
 function ensurePlanFromActivityProjection(state, activity) {
   const actKey = activity.key ?? null;
+  if (state.plan?.some((step) => step.owner === 'orchestrator')) {
+    attachActivityToExistingPlan(state.plan, activity);
+    return;
+  }
   if (state.plan && actKey !== null && state.plan[0]?._activityKey === actKey) return;
   const steps = activity.plan?.steps;
   if (Array.isArray(steps) && steps.length > 0) {
@@ -219,6 +323,8 @@ function ensurePlanFromActivityProjection(state, activity) {
       id: step.id ?? null,
       description: step.label,
       status: 'pending',
+      owner: 'activity',
+      ownerActivityKey: activity.key,
       _activityKey: activity.key,
     }));
     return;
@@ -228,12 +334,16 @@ function ensurePlanFromActivityProjection(state, activity) {
     id: null,
     description: activity.label,
     status: 'pending',
+    owner: 'activity',
+    ownerActivityKey: activity.key,
     _activityKey: activity.key,
   }];
 }
 
 function normalizePlan(steps, payload = {}) {
   if (!Array.isArray(steps)) return null;
+  const owner = payload.owner ?? 'orchestrator';
+  const ownerActivityKey = payload.ownerActivityKey ?? payload.activityKey ?? null;
   return steps.map((raw, i) => {
     const item = typeof raw === 'string' ? { description: raw } : (raw ?? {});
     return {
@@ -241,11 +351,21 @@ function normalizePlan(steps, payload = {}) {
       id: item.id ?? null,
       description: String(item.description ?? item.label ?? item.name ?? `Step ${i + 1}`),
       status: item.status ?? 'pending',
+      owner: item.owner ?? owner,
+      ownerActivityKey: item.ownerActivityKey ?? ownerActivityKey,
       _activityKey: item._activityKey ?? payload.activityKey ?? null,
     };
   });
 }
 
+function defaultRunPlan() {
+  return [
+    { step: 1, id: 'analyze', description: 'Analyze the request', status: 'running', owner: 'orchestrator', ownerActivityKey: null, _activityKey: null },
+    { step: 2, id: 'execute', description: 'Execute the required actions', status: 'pending', owner: 'orchestrator', ownerActivityKey: null, _activityKey: null },
+    { step: 3, id: 'verify', description: 'Verify the result', status: 'pending', owner: 'orchestrator', ownerActivityKey: null, _activityKey: null },
+  ];
+}
+
 function updatePlanStep(plan, payload) {
   if (!plan) return;
   const step = plan.find((item) => item.step === Number(payload.step));