@dotdrelle/wiki-manager 0.6.47 → 0.8.2

package/src/core/agentEvents.js

@@ -1,15 +1,41 @@
 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',
 ]);
 
-export function createAgentEvent(type, { origin = 'system', payload = {}, runId = null, turnId = null } = {}) {
+// Events that can mutate state.plan in applyEvent() — only these warrant the
+// before/after plan comparison below (runtime_log fires far more often and
+// never touches the plan).
+const PLAN_MUTATING_EVENTS = new Set([
+  'run_started',
+  'plan_set',
+  'plan_step_updated',
+  'activity_upserted',
+  'run_done',
+]);
+
+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(),
@@ -17,13 +43,18 @@ 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 previousPlan = JSON.stringify(session.headlessPlan ?? null);
+  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 ??= [];
   session.agentEvents.push(normalized);
   session._agentProjectionState ??= createProjectionState();
@@ -31,13 +62,25 @@ export function dispatchAgentEvent(session, event) {
   session.agentProjection = publicProjection(session._agentProjectionState);
   if (SESSION_PROJECTION_EVENTS.has(normalized.type)) {
     applyAgentProjectionToSession(session, session.agentProjection);
-    if (JSON.stringify(session.headlessPlan ?? null) !== previousPlan) {
+    if (tracksPlan && JSON.stringify(session.headlessPlan ?? null) !== previousPlan) {
       session._onPlanUpdate?.();
     }
   }
+  session._onAgentEvent?.(normalized, session.agentProjection);
   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();
 
@@ -55,6 +98,9 @@ function createProjectionState() {
     plan: null,
     activities: {},
     logs: [],
+    evaluation: null,
+    replans: [],
+    approvals: [],
     summary: null,
     status: 'idle',
   };
@@ -67,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,
   };
@@ -89,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':
@@ -130,13 +182,63 @@ 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';
+      state.logs.push(String(event.payload?.message ?? 'Agent run cancelled.'));
       return;
     case 'run_error':
       state.status = 'error';
       state.logs.push(String(event.payload?.message ?? 'Agent run failed.'));
       return;
+    case 'runtime_log':
+      state.logs.push(String(event.payload?.message ?? ''));
+      state.logs = state.logs.slice(-200);
+      return;
     default:
       return;
   }
@@ -176,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;
@@ -189,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) {
@@ -197,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;
@@ -206,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 {
@@ -219,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));

package/src/core/agentEvents.test.js

@@ -22,7 +22,9 @@ test('reduceAgentEvents: run_started clears stale plan', () => {
     }),
     createAgentEvent('run_started', { origin: 'user' }),
   ]);
-  assert.equal(projection.plan, null);
+  assert.equal(projection.plan.length, 3);
+  assert.equal(projection.plan[0].description, 'Analyze the request');
+  assert.equal(projection.plan[0].owner, 'orchestrator');
   assert.equal(projection.activities.length, 0);
   assert.equal(projection.status, 'running');
 });
@@ -67,7 +69,7 @@ test('reduceAgentEvents: activity with plan creates visible plan and progress',
   assert.equal(projection.plan[1].status, 'pending');
 });
 
-test('reduceAgentEvents: real activity replaces minimal MCP plan', () => {
+test('reduceAgentEvents: activity attaches to orchestrator plan without replacing it', () => {
   const projection = reduceAgentEvents([
     createAgentEvent('plan_set', {
       origin: 'tool',
@@ -87,8 +89,147 @@ test('reduceAgentEvents: real activity replaces minimal MCP plan', () => {
     }),
   ]);
   assert.equal(projection.plan.length, 1);
-  assert.equal(projection.plan[0].description, 'CME export');
-  assert.equal(projection.plan[0]._activityKey, 'cme:export-1');
+  assert.equal(projection.plan[0].description, 'cme.cme_export_run');
+  assert.equal(projection.plan[0].owner, 'orchestrator');
+  assert.equal(projection.plan[0].activityKey, 'cme:export-1');
+  assert.equal(projection.plan[0].ownerActivityKey, 'cme:export-1');
+});
+
+test('reduceAgentEvents: run activity attaches to execution step of default plan', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('run_started', { origin: 'runtime' }),
+    createAgentEvent('activity_upserted', {
+      origin: 'tool',
+      payload: {
+        activity: {
+          key: 'production:build-1',
+          id: 'build-1',
+          source: 'production',
+          label: 'Production build',
+          status: 'running',
+        },
+      },
+    }),
+  ]);
+
+  assert.equal(projection.plan[0].status, 'done');
+  assert.equal(projection.plan[1].status, 'running');
+  assert.equal(projection.plan[1].activityKey, 'production:build-1');
+  assert.equal(projection.plan[2].status, 'pending');
+});
+
+test('reduceAgentEvents: run_done finalizes running and pending plan steps', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('run_started', { origin: 'runtime' }),
+    createAgentEvent('run_done', { origin: 'runtime' }),
+  ]);
+
+  assert.deepEqual(projection.plan.map((step) => step.status), ['done', 'done', 'done']);
+  assert.equal(projection.status, 'done');
+});
+
+test('dispatchAgentEvent: run_done finalizes session plan', () => {
+  const session = {};
+  dispatchAgentEvent(session, createAgentEvent('run_started', { origin: 'runtime' }));
+  dispatchAgentEvent(session, createAgentEvent('run_done', { origin: 'runtime' }));
+
+  assert.deepEqual(session.headlessPlan.map((step) => step.status), ['done', 'done', 'done']);
+  assert.equal(session.agentProjection.status, 'done');
+});
+
+test('reduceAgentEvents: run_evaluated exposes evaluator verdict', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('run_started', { origin: 'runtime', runId: 'run-1' }),
+    createAgentEvent('run_evaluated', {
+      origin: 'runtime',
+      runId: 'run-1',
+      payload: {
+        ok: false,
+        reason: 'Missing export.',
+        suggestedAction: 'Run export step.',
+      },
+    }),
+  ]);
+
+  assert.deepEqual(projection.evaluation, {
+    ok: false,
+    reason: 'Missing export.',
+    suggestedAction: 'Run export step.',
+    runId: 'run-1',
+  });
+  assert.equal(projection.status, 'running');
+});
+
+test('reduceAgentEvents: run_replanned records replan trace', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('run_started', { origin: 'runtime', runId: 'run-1' }),
+    createAgentEvent('run_replanned', {
+      origin: 'runtime',
+      runId: 'run-1',
+      payload: {
+        reason: 'Export file missing.',
+        plan: ['Run export again'],
+        replansLeft: 1,
+      },
+    }),
+  ]);
+
+  assert.deepEqual(projection.replans, [{
+    reason: 'Export file missing.',
+    plan: ['Run export again'],
+    replansLeft: 1,
+    runId: 'run-1',
+  }]);
+});
+
+test('reduceAgentEvents: approvals move from pending to approved', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('run_pending_approval', {
+      origin: 'runtime',
+      runId: 'run-1',
+      payload: {
+        approvalId: 'approval-1',
+        runId: 'run-1',
+        reason: 'Approve plan.',
+        plan: ['Build'],
+      },
+    }),
+    createAgentEvent('run_approved', {
+      origin: 'runtime',
+      runId: 'run-1',
+      payload: {
+        approvalId: 'approval-1',
+        runId: 'run-1',
+      },
+    }),
+  ]);
+
+  assert.equal(projection.approvals.length, 1);
+  assert.equal(projection.approvals[0].status, 'approved');
+  assert.equal(projection.approvals[0].scope, 'run');
+  assert.deepEqual(projection.approvals[0].plan, ['Build']);
+});
+
+test('reduceAgentEvents: activity-owned plan is used when no orchestrator plan exists', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('activity_upserted', {
+      origin: 'tool',
+      payload: {
+        activity: {
+          key: 'production:job-1',
+          id: 'job-1',
+          source: 'production',
+          label: 'Production build',
+          status: 'running',
+        },
+      },
+    }),
+  ]);
+
+  assert.equal(projection.plan.length, 1);
+  assert.equal(projection.plan[0].description, 'Production build');
+  assert.equal(projection.plan[0].owner, 'activity');
+  assert.equal(projection.plan[0].ownerActivityKey, 'production:job-1');
 });
 
 test('dispatchAgentEvent: writes compatibility projections to session', () => {

package/src/core/agentLoop.js

@@ -0,0 +1,167 @@
+import { buildAgentSystemPrompt, buildLimitedAgentResponse } from '../agent/graph.js';
+import { createAgentEvent, dispatchAgentEvent } from './agentEvents.js';
+import { activitySnapshot, newNonTerminalActivities } from './activity.js';
+import { extractHeadlessPlan, formatCompletedActivities, formatPlanStatus } from './plan.js';
+
+export function abortError(message = 'Agent run cancelled.') {
+  const err = new Error(message);
+  err.name = 'AbortError';
+  return err;
+}
+
+export function throwIfAborted(signal, message) {
+  if (signal?.aborted) throw abortError(message);
+}
+
+export async function runAgentTurn(agent, session, input, {
+  messages = [],
+  signal = null,
+} = {}) {
+  let streamedContent = '';
+  session._onStream = (delta) => { streamedContent += delta; };
+  session._onStreamReset = () => { streamedContent = ''; };
+  let result;
+  try {
+    result = await agent.invoke({ input, session, messages });
+  } finally {
+    delete session._onStream;
+    delete session._onStreamReset;
+  }
+  if (result.streamedInline) {
+    return streamedContent.trim() || buildLimitedAgentResponse({ input, session }, 'LLM stream ended without content');
+  }
+  if (result.response != null) return result.response;
+  if (result.readyToStream && session.llm?.stream) {
+    const { system, messages: streamMessages = [] } = result.streamContext ?? {};
+    let content = '';
+    for await (const delta of session.llm.stream({
+      system: system ?? buildAgentSystemPrompt({ input, session }),
+      messages: streamMessages,
+      signal,
+    })) {
+      content += delta;
+    }
+    return content.trim() || buildLimitedAgentResponse({ input, session }, 'LLM stream ended without content');
+  }
+  return buildLimitedAgentResponse({ input, session });
+}
+
+export async function runAgenticLoop(agent, session, initialInput, {
+  maxTurns,
+  timeoutMs,
+  signal = null,
+  runId = null,
+  runTurn = runAgentTurn,
+  waitForActivities,
+  planOrigin = 'llm',
+  onTurnStart = null,
+  onTurnResponse = null,
+  onAssistantMessage = null,
+  onPlanExtracted = null,
+  onPlanAlreadySet = null,
+  onComplete = null,
+  onPendingSteps = null,
+  onActivitiesStarted = null,
+  onActivitiesCompleted = null,
+  onMaxTurns = null,
+  abortMessage = 'Agent run cancelled.',
+} = {}) {
+  if (!waitForActivities) throw new Error('runAgenticLoop requires waitForActivities.');
+  const conversationHistory = [];
+  let currentInput = initialInput;
+
+  for (let turn = 1; turn <= maxTurns; turn += 1) {
+    throwIfAborted(signal, abortMessage);
+    if (session._currentRunIdentity && runId) {
+      session._currentRunIdentity.turnId = `${runId}:turn-${turn}`;
+    }
+    onTurnStart?.({ turn, maxTurns });
+
+    const snapshot = activitySnapshot(session);
+    const response = await runTurn(agent, session, currentInput, {
+      messages: conversationHistory,
+      signal,
+    });
+    onTurnResponse?.({ turn, response });
+    onAssistantMessage?.({ response, runId });
+
+    conversationHistory.push(
+      { role: 'user', content: currentInput },
+      { role: 'assistant', content: response },
+    );
+
+    if (turn === 1) {
+      if (session.headlessPlan === null) {
+        const extractedPlan = extractHeadlessPlan(response);
+        if (extractedPlan) {
+          dispatchAgentEvent(session, createAgentEvent('plan_set', {
+            origin: planOrigin,
+            runId,
+            payload: { steps: extractedPlan },
+          }));
+          onPlanExtracted?.({ steps: session.headlessPlan ?? extractedPlan, fallback: true });
+        }
+      } else {
+        onPlanAlreadySet?.({ steps: session.headlessPlan });
+      }
+    }
+
+    const newPending = newNonTerminalActivities(snapshot, session);
+    if (newPending.length === 0) {
+      const pendingSteps = (session.headlessPlan ?? []).filter((step) => step.status === 'pending');
+      if (pendingSteps.length === 0) {
+        onComplete?.();
+        return { ok: true };
+      }
+      onPendingSteps?.({ pendingSteps });
+      currentInput = pendingStepsPrompt(initialInput, session.headlessPlan);
+      continue;
+    }
+
+    onActivitiesStarted?.({ activities: newPending });
+    const waitResult = await waitForActivities(session, newPending, { timeoutMs, signal });
+    if (!waitResult.ok) {
+      return {
+        ok: false,
+        timedOut: Boolean(waitResult.timedOut),
+        completed: waitResult.completed ?? [],
+        waitResult,
+      };
+    }
+
+    const completed = waitResult.completed ?? [];
+    const summary = formatCompletedActivities(completed);
+    onActivitiesCompleted?.({ completed, summary });
+    currentInput = completedActivitiesPrompt(initialInput, session.headlessPlan, summary);
+  }
+
+  onMaxTurns?.({ maxTurns });
+  return { ok: false, maxTurns: true };
+}
+
+function pendingStepsPrompt(initialInput, plan) {
+  return [
+    'Original task:',
+    initialInput,
+    '',
+    `Plan status:\n${formatPlanStatus(plan)}`,
+    '',
+    'No new background activity was started in the previous turn.',
+    'Continue the original plan. Start the next pending step only.',
+    'If required information is missing and cannot be inferred, stop with a clear blocker.',
+  ].join('\n');
+}
+
+function completedActivitiesPrompt(initialInput, plan, summary) {
+  return [
+    'Original task:',
+    initialInput,
+    '',
+    plan ? `Plan status:\n${formatPlanStatus(plan)}\n` : null,
+    'Completed activities:',
+    summary,
+    '',
+    'Continue the original plan. Start the next required step only.',
+    'If all steps are complete, provide the final summary.',
+  ].filter(Boolean).join('\n');
+}

package/src/core/agentLoop.test.js

@@ -0,0 +1,85 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createAgentEvent, dispatchAgentEvent } from './agentEvents.js';
+import { runAgenticLoop } from './agentLoop.js';
+
+test('runAgenticLoop waits for new activities and continues with a completion summary', async () => {
+  const session = {
+    activities: {},
+    headlessPlan: null,
+  };
+  const inputs = [];
+  const callbacks = [];
+  const agent = {
+    async invoke({ input, session: turnSession }) {
+      inputs.push(input);
+      if (inputs.length === 1) {
+        dispatchAgentEvent(turnSession, createAgentEvent('activity_upserted', {
+          payload: {
+            activity: {
+              id: 'job-1',
+              source: 'production',
+              kind: 'job',
+              label: 'production job',
+              status: 'running',
+              terminal: false,
+            },
+          },
+        }));
+        return { response: 'Started production job.' };
+      }
+      return { response: 'All done.' };
+    },
+  };
+
+  const result = await runAgenticLoop(agent, session, 'Build workspace', {
+    maxTurns: 3,
+    timeoutMs: 1000,
+    waitForActivities: async (turnSession, startedActivities) => {
+      assert.equal(startedActivities.length, 1);
+      dispatchAgentEvent(turnSession, createAgentEvent('activity_upserted', {
+        payload: {
+          activity: {
+            id: 'job-1',
+            source: 'production',
+            kind: 'job',
+            label: 'production job',
+            status: 'done',
+            terminal: true,
+          },
+        },
+      }));
+      if (turnSession.headlessPlan?.[0]) turnSession.headlessPlan[0].status = 'done';
+      return { ok: true, completed: Object.values(turnSession.activities) };
+    },
+    onActivitiesStarted: ({ activities }) => callbacks.push(`started:${activities.length}`),
+    onActivitiesCompleted: ({ summary }) => callbacks.push(summary),
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(inputs.length, 2);
+  assert.match(inputs[1], /Completed activities:/);
+  assert.match(inputs[1], /production job-1: done/);
+  assert.deepEqual(callbacks, ['started:1', '- production job-1: done']);
+});
+
+test('runAgenticLoop extracts a fallback numbered plan from first response', async () => {
+  const session = {
+    activities: {},
+    headlessPlan: null,
+  };
+  const result = await runAgenticLoop({
+    async invoke() {
+      return { response: '1. Collect sources\n2. Build page' };
+    },
+  }, session, 'Plan task', {
+    maxTurns: 1,
+    timeoutMs: 1000,
+    waitForActivities: async () => assert.fail('No activities should be waited for.'),
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.maxTurns, true);
+  assert.equal(session.headlessPlan.length, 2);
+  assert.equal(session.headlessPlan[0].description, 'Collect sources');
+});