@dotdrelle/wiki-manager 0.7.3 → 0.9.3

package/src/runtime/lifecycle.js

@@ -1,4 +1,4 @@
-import { spawn } from 'node:child_process';
+import { execFile, spawn } from 'node:child_process';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { checkRuntimeHealth, runtimeUrlFromEnv } from './client.js';
@@ -9,6 +9,29 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const managerRoot = resolve(__dirname, '../..');
 const binPath = resolve(managerRoot, 'bin/wiki-manager.js');
 
+export function runtimeNodeExecutable() {
+  return process.versions.bun
+    ? (process.env.WIKI_MANAGER_NODE_BIN ?? 'node')
+    : process.execPath;
+}
+
+export async function assertRuntimeNode(executable = runtimeNodeExecutable()) {
+  const version = await new Promise((resolveVersion, reject) => {
+    execFile(executable, ['-p', 'process.versions.node'], (err, stdout) => {
+      if (err) {
+        reject(new Error(`Runtime requires Node.js 22+; could not execute ${executable}. Set WIKI_MANAGER_NODE_BIN to a Node.js 22 binary.`));
+        return;
+      }
+      resolveVersion(String(stdout).trim());
+    });
+  });
+  const major = Number(String(version).split('.')[0]);
+  if (!Number.isInteger(major) || major < 22) {
+    throw new Error(`Runtime requires Node.js 22+ for node:sqlite; ${executable} is Node ${version}. Set WIKI_MANAGER_NODE_BIN to a Node.js 22 binary.`);
+  }
+  return { executable, version };
+}
+
 export async function ensureRuntime({
   host = process.env.WIKI_MANAGER_RUNTIME_HOST ?? '0.0.0.0',
   port = Number(process.env.WIKI_MANAGER_RUNTIME_PORT ?? 7788),
@@ -21,7 +44,8 @@ export async function ensureRuntime({
   const existing = await runtimeHealthOrNull(url, auth.token);
   if (existing) return { url, started: false, health: existing, token: auth.token, tokenPath: auth.tokenPath };
 
-  const child = spawn(process.execPath, [
+  const runtimeNode = await assertRuntimeNode();
+  const child = spawn(runtimeNode.executable, [
     binPath,
     'runtime',
     '--host',
@@ -45,7 +69,7 @@ export async function ensureRuntime({
   let health = null;
   while (Date.now() < deadline) {
     health = await runtimeHealthOrNull(url, auth.token);
-    if (health) return { url, started: true, health, pid: child.pid, token: auth.token, tokenPath: auth.tokenPath };
+    if (health) return { url, started: true, health, pid: child.pid, token: auth.token, tokenPath: auth.tokenPath, node: runtimeNode };
     await new Promise((resolveDelay) => setTimeout(resolveDelay, 150));
   }
   throw new Error(`Runtime did not become healthy at ${url}`);

package/src/runtime/queueStore.js

@@ -1,6 +1,6 @@
 import { createQueueStore } from '../core/queueStore.js';
 
-export function createSqliteQueueStore(store, session) {
-  session.jobQueue = store.listQueue();
-  return createQueueStore(session, { persist: () => store.saveQueue(session.jobQueue) });
+export function createSqliteQueueStore(store, session, { workspace = session.workspace ?? null } = {}) {
+  session.jobQueue = store.listQueue({ workspace });
+  return createQueueStore(session, { persist: () => store.saveQueue(session.jobQueue, { workspace }) });
 }

package/src/runtime/runner.js

@@ -1,8 +1,11 @@
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { sessionActivities, terminalFailures } from '../core/activity.js';
 import { runAgenticLoop, throwIfAborted } from '../core/agentLoop.js';
+import { formatPlanStatus } from '../core/plan.js';
 import { emitRuntimeLog, pollActivitiesOnce } from './supervisor.js';
 
+const DEFAULT_MAX_REPLANS = 2;
+
 async function waitForRuntimeActivities(session, startedActivities, { timeoutMs, signal, pollBusy }) {
   const deadline = Date.now() + timeoutMs;
   const trackedKeys = new Set(startedActivities.map((activity) => activity.key));
@@ -71,3 +74,340 @@ export async function runRuntimeAgenticLoop(agent, session, initialInput, { sign
     },
   });
 }
+
+export async function runRuntimeAgenticWorkflow(agent, session, input, {
+  initialInput = null,
+  signal = null,
+  timeoutMs,
+  maxTurns,
+  runId,
+  pollBusy,
+  evaluate = true,
+  maxReplans = resolveMaxReplans(),
+} = {}) {
+  let currentInput = initialInput ?? input;
+  let replansLeft = Math.max(0, Math.floor(Number(maxReplans) || 0));
+
+  while (true) {
+    const result = await runRuntimeAgenticLoop(agent, session, currentInput, {
+      signal,
+      timeoutMs,
+      maxTurns,
+      runId,
+      pollBusy,
+    });
+    if (!result.ok) {
+      const trigger = replanTriggerFromLoopResult(result);
+      if (trigger && replansLeft > 0) {
+        const replanned = await replanRuntimeRun(session, input, trigger, {
+          runId,
+          signal,
+          replansLeft: replansLeft - 1,
+        });
+        if (replanned.ok) {
+          replansLeft -= 1;
+          currentInput = buildReplannedRunPrompt(input, trigger, replanned.steps);
+          continue;
+        }
+      }
+      dispatchAgentEvent(session, createAgentEvent('run_error', {
+        origin: 'runtime',
+        runId,
+        payload: {
+          runId,
+          message: runtimeLoopErrorMessage(result),
+        },
+      }));
+      return { ok: false, result };
+    }
+
+    const evaluation = await evaluateRuntimeRun(session, input, { runId, signal, evaluate });
+    if (evaluation) {
+      dispatchAgentEvent(session, createAgentEvent('run_evaluated', {
+        origin: 'runtime',
+        runId,
+        payload: {
+          runId,
+          ok: evaluation.ok,
+          reason: evaluation.reason,
+          suggestedAction: evaluation.suggestedAction ?? null,
+        },
+      }));
+      if (!evaluation.ok) {
+        if (replansLeft > 0) {
+          const trigger = {
+            kind: 'evaluation',
+            reason: evaluation.reason,
+            suggestedAction: evaluation.suggestedAction ?? null,
+          };
+          const replanned = await replanRuntimeRun(session, input, trigger, {
+            runId,
+            signal,
+            replansLeft: replansLeft - 1,
+          });
+          if (replanned.ok) {
+            replansLeft -= 1;
+            currentInput = buildReplannedRunPrompt(input, trigger, replanned.steps);
+            continue;
+          }
+        }
+        dispatchAgentEvent(session, createAgentEvent('run_error', {
+          origin: 'runtime',
+          runId,
+          payload: {
+            runId,
+            message: `Runtime evaluator rejected the run: ${evaluation.reason}`,
+            suggestedAction: evaluation.suggestedAction ?? null,
+          },
+        }));
+        return { ok: false, evaluation, evaluationRejected: true };
+      }
+    }
+
+    dispatchAgentEvent(session, createAgentEvent('run_done', {
+      origin: 'runtime',
+      runId,
+      payload: { runId },
+    }));
+    return { ok: true, evaluation };
+  }
+}
+
+export async function finishRuntimeRun(session, input, {
+  runId,
+  signal = null,
+  evaluate = true,
+} = {}) {
+  const evaluation = await evaluateRuntimeRun(session, input, { runId, signal, evaluate });
+  if (evaluation) {
+    dispatchAgentEvent(session, createAgentEvent('run_evaluated', {
+      origin: 'runtime',
+      runId,
+      payload: {
+        runId,
+        ok: evaluation.ok,
+        reason: evaluation.reason,
+        suggestedAction: evaluation.suggestedAction ?? null,
+      },
+    }));
+    if (!evaluation.ok) {
+      dispatchAgentEvent(session, createAgentEvent('run_error', {
+        origin: 'runtime',
+        runId,
+        payload: {
+          runId,
+          message: `Runtime evaluator rejected the run: ${evaluation.reason}`,
+          suggestedAction: evaluation.suggestedAction ?? null,
+        },
+      }));
+      return { ok: false, evaluation, evaluationRejected: true };
+    }
+  }
+  dispatchAgentEvent(session, createAgentEvent('run_done', {
+    origin: 'runtime',
+    runId,
+    payload: { runId },
+  }));
+  return { ok: true, evaluation };
+}
+
+export async function evaluateRuntimeRun(session, input, {
+  runId = null,
+  signal = null,
+  evaluate = true,
+} = {}) {
+  if (!shouldEvaluate(evaluate)) return null;
+  const llm = session.llm;
+  if (!llm || typeof llm.completeWithTools !== 'function') {
+    return fallbackEvaluation('Evaluator unavailable: no LLM completeWithTools client.');
+  }
+  try {
+    emitRuntimeLog(session, 'runtime: evaluating completed run');
+    const result = await llm.completeWithTools({
+      system: [
+        'You are a strict evaluator for an agentic runtime run.',
+        'Inspect whether the original task was accomplished using the final plan and recent conversation.',
+        'Return only JSON with this exact shape: {"ok":boolean,"reason":"...","suggestedAction":string|null}.',
+        'Use ok=false only when a concrete missing action, failed requirement, or wrong result is visible.',
+      ].join('\n'),
+      tools: [],
+      messages: [{ role: 'user', content: buildEvaluationPrompt(input, session, { runId }) }],
+      signal,
+    });
+    return normalizeEvaluation(parseJsonFenced(result.content, 'evaluator response'));
+  } catch (err) {
+    return fallbackEvaluation(`Evaluator unavailable: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+
+function shouldEvaluate(value) {
+  if (value === false) return false;
+  const env = String(process.env.WIKI_MANAGER_EVALUATOR ?? '').trim().toLowerCase();
+  return !['0', 'false', 'off', 'no'].includes(env);
+}
+
+function buildEvaluationPrompt(input, session, { runId = null } = {}) {
+  const recentConversation = formatRecentConversation(session);
+  const activities = sessionActivities(session)
+    .slice(-12)
+    .map((activity) => `- ${activity.label ?? activity.id}: ${activity.status}${activity.error ? ` (${activity.error})` : ''}`)
+    .join('\n');
+  return [
+    runId ? `Run id: ${runId}` : null,
+    'Original task:',
+    input || '(unknown)',
+    '',
+    session.headlessPlan ? `Final plan:\n${formatPlanStatus(session.headlessPlan)}` : 'Final plan: none',
+    activities ? `Recent activities:\n${activities}` : null,
+    recentConversation ? `Recent conversation:\n${recentConversation}` : null,
+    '',
+    'Return JSON only.',
+  ].filter(Boolean).join('\n');
+}
+
+function parseJsonFenced(content, label = 'JSON response') {
+  const text = String(content ?? '').trim();
+  if (!text) throw new Error(`empty ${label}`);
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  return JSON.parse(fenced ? fenced[1].trim() : text);
+}
+
+function normalizeEvaluation(value) {
+  return {
+    ok: value?.ok === true,
+    reason: String(value?.reason ?? '').trim() || (value?.ok === true ? 'Task completed.' : 'Evaluator rejected the run.'),
+    suggestedAction: value?.suggestedAction == null ? null : String(value.suggestedAction),
+  };
+}
+
+function fallbackEvaluation(reason) {
+  return {
+    ok: true,
+    reason,
+    suggestedAction: null,
+  };
+}
+
+export async function replanRuntimeRun(session, input, trigger, {
+  runId = null,
+  signal = null,
+  replansLeft = 0,
+} = {}) {
+  const llm = session.llm;
+  if (!llm || typeof llm.completeWithTools !== 'function') {
+    return { ok: false, reason: 'Replanner unavailable: no LLM completeWithTools client.' };
+  }
+  try {
+    emitRuntimeLog(session, 'runtime: replanning remaining work');
+    const result = await llm.completeWithTools({
+      system: [
+        'You are a replanner for an agentic runtime run.',
+        'Given the original objective, current plan, and failure reason, return only the remaining steps required.',
+        'Do not include steps that are already done.',
+        'Return only JSON with this exact shape: {"steps":["..."]}.',
+      ].join('\n'),
+      tools: [],
+      messages: [{ role: 'user', content: buildReplanPrompt(input, session, trigger) }],
+      signal,
+    });
+    const steps = normalizeReplan(parseJsonFenced(result.content, 'replan response').steps);
+    if (steps.length === 0) throw new Error('empty replan');
+    dispatchAgentEvent(session, createAgentEvent('run_replanned', {
+      origin: 'runtime',
+      runId,
+      payload: {
+        runId,
+        reason: trigger.reason,
+        plan: steps,
+        replansLeft,
+      },
+    }));
+    dispatchAgentEvent(session, createAgentEvent('plan_set', {
+      origin: 'runtime',
+      runId,
+      payload: {
+        steps: steps.map((description, index) => ({
+          step: index + 1,
+          description,
+          status: 'pending',
+        })),
+      },
+    }));
+    return { ok: true, steps };
+  } catch (err) {
+    return { ok: false, reason: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+function replanTriggerFromLoopResult(result) {
+  const failures = terminalFailures(result.completed ?? []);
+  const failure = failures[0];
+  if (!failure) return null;
+  return {
+    kind: 'activity_error',
+    reason: `${failure.label ?? failure.id ?? 'Activity'} ended with ${failure.status}${failure.error ? `: ${failure.error}` : ''}`,
+    suggestedAction: failure.error ?? null,
+    activity: failure,
+  };
+}
+
+function runtimeLoopErrorMessage(result) {
+  if (result.timedOut) return 'Runtime agentic loop timed out.';
+  if (result.maxTurns) return 'Runtime agentic loop reached max turns.';
+  const trigger = replanTriggerFromLoopResult(result);
+  return trigger?.reason ?? 'Runtime agentic loop failed.';
+}
+
+function buildReplanPrompt(input, session, trigger) {
+  const recentConversation = formatRecentConversation(session);
+  return [
+    'Original task:',
+    input || '(unknown)',
+    '',
+    session.headlessPlan ? `Current plan:\n${formatPlanStatus(session.headlessPlan)}` : 'Current plan: none',
+    '',
+    `Failure source: ${trigger.kind}`,
+    `Failure reason: ${trigger.reason}`,
+    trigger.suggestedAction ? `Suggested action: ${trigger.suggestedAction}` : null,
+    recentConversation ? `Recent conversation:\n${recentConversation}` : null,
+    '',
+    'Return only the remaining steps still required. Exclude already completed steps.',
+  ].filter(Boolean).join('\n');
+}
+
+function buildReplannedRunPrompt(input, trigger, steps) {
+  return [
+    'Continue a replanned runtime run.',
+    '',
+    'Original task:',
+    input || '(unknown)',
+    '',
+    `Replan reason: ${trigger.reason}`,
+    '',
+    'New partial plan:',
+    ...steps.map((step, index) => `${index + 1}. ${step}`),
+    '',
+    'Execute only the first pending replanned step. Do not repeat completed work.',
+  ].join('\n');
+}
+
+function normalizeReplan(steps) {
+  if (!Array.isArray(steps)) return [];
+  return steps
+    .map((step) => String(step ?? '').trim())
+    .filter(Boolean)
+    .slice(0, 12);
+}
+
+function formatRecentConversation(session, n = 12) {
+  const conversation = session.agentProjection?.conversation ?? [];
+  return conversation
+    .slice(-n)
+    .map((message) => `${message.role}: ${message.content}`)
+    .join('\n');
+}
+
+function resolveMaxReplans(value = process.env.WIKI_MANAGER_REPLANNER_MAX_REPLANS) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? Math.max(0, Math.floor(parsed)) : DEFAULT_MAX_REPLANS;
+}

package/src/runtime/runner.test.js

@@ -0,0 +1,270 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
+import { finishRuntimeRun, runRuntimeAgenticWorkflow } from './runner.js';
+
+test('finishRuntimeRun emits evaluation before run_done', async () => {
+  const events = [];
+  const session = {
+    activities: {},
+    headlessPlan: [
+      { step: 1, description: 'Analyze', status: 'done' },
+      { step: 2, description: 'Execute', status: 'done' },
+    ],
+    agentProjection: {
+      conversation: [{ role: 'assistant', content: 'Done.' }],
+    },
+    llm: {
+      async completeWithTools({ system, tools, messages }) {
+        assert.match(system, /strict evaluator/);
+        assert.deepEqual(tools, []);
+        assert.match(messages[0].content, /Original task:/);
+        return { content: '{"ok":true,"reason":"Task complete.","suggestedAction":null}' };
+      },
+    },
+    _onAgentEvent: (event) => events.push(event),
+  };
+
+  const result = await finishRuntimeRun(session, 'Build workspace', { runId: 'run-1' });
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(events.map((event) => event.type), ['runtime_log', 'run_evaluated', 'run_done']);
+  assert.equal(session.agentProjection.evaluation.ok, true);
+  assert.equal(session.agentProjection.status, 'done');
+});
+
+test('finishRuntimeRun turns negative evaluation into run_error', async () => {
+  const events = [];
+  const session = {
+    activities: {},
+    headlessPlan: [{ step: 1, description: 'Export', status: 'done' }],
+    agentProjection: {
+      conversation: [{ role: 'assistant', content: 'Done.' }],
+    },
+    llm: {
+      async completeWithTools() {
+        return { content: '{"ok":false,"reason":"Export file missing.","suggestedAction":"Run export again."}' };
+      },
+    },
+    _onAgentEvent: (event) => events.push(event),
+  };
+
+  const result = await finishRuntimeRun(session, 'Export deliverable', { runId: 'run-2' });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.evaluationRejected, true);
+  assert.deepEqual(events.map((event) => event.type), ['runtime_log', 'run_evaluated', 'run_error']);
+  assert.equal(session.agentProjection.evaluation.ok, false);
+  assert.equal(session.agentProjection.status, 'error');
+  assert.match(session.agentProjection.logs.at(-1), /Export file missing/);
+});
+
+test('finishRuntimeRun falls back open when evaluator response is invalid', async () => {
+  const session = {
+    activities: {},
+    headlessPlan: null,
+    agentProjection: { conversation: [] },
+    llm: {
+      async completeWithTools() {
+        return { content: 'not json' };
+      },
+    },
+  };
+
+  const result = await finishRuntimeRun(session, 'Do work', { runId: 'run-3' });
+
+  assert.equal(result.ok, true);
+  assert.equal(session.agentProjection.evaluation.ok, true);
+  assert.match(session.agentProjection.evaluation.reason, /Evaluator unavailable/);
+  assert.equal(session.agentProjection.status, 'done');
+});
+
+test('finishRuntimeRun can skip evaluation', async () => {
+  let called = false;
+  const session = {
+    activities: {},
+    headlessPlan: null,
+    agentProjection: { conversation: [] },
+    llm: {
+      async completeWithTools() {
+        called = true;
+        return { content: '{"ok":true,"reason":"ok"}' };
+      },
+    },
+  };
+
+  const result = await finishRuntimeRun(session, 'Do work', { runId: 'run-4', evaluate: false });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.evaluation, null);
+  assert.equal(called, false);
+  assert.equal(session.agentProjection.evaluation, null);
+  assert.equal(session.agentProjection.status, 'done');
+});
+
+test('runRuntimeAgenticWorkflow replans after negative evaluation', async () => {
+  const events = [];
+  const llmCalls = [];
+  const session = {
+    activities: {},
+    headlessPlan: null,
+    llm: {
+      async completeWithTools({ system }) {
+        llmCalls.push(system);
+        if (/strict evaluator/.test(system) && llmCalls.length === 1) {
+          return { content: '{"ok":false,"reason":"Export missing.","suggestedAction":"Run export."}' };
+        }
+        if (/replanner/.test(system)) {
+          return { content: '{"steps":["Run export"]}' };
+        }
+        return { content: '{"ok":true,"reason":"Export complete.","suggestedAction":null}' };
+      },
+    },
+    _onAgentEvent: (event) => events.push(event),
+  };
+  let turns = 0;
+  const agent = {
+    async invoke({ session: turnSession }) {
+      turns += 1;
+      if (turnSession.headlessPlan?.[0]?.status === 'pending') {
+        dispatchAgentEvent(turnSession, createAgentEvent('plan_step_updated', {
+          origin: 'tool',
+          payload: { step: 1, status: 'done' },
+        }));
+      }
+      return { response: turns === 1 ? 'Initial done.' : 'Export done.' };
+    },
+  };
+
+  const result = await runRuntimeAgenticWorkflow(agent, session, 'Export deliverable', {
+    runId: 'run-replan-eval',
+    timeoutMs: 1000,
+    maxTurns: 2,
+    maxReplans: 1,
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(turns, 2);
+  assert.ok(events.some((event) => event.type === 'run_replanned'));
+  assert.deepEqual(session.agentProjection.replans[0].plan, ['Run export']);
+  assert.equal(session.agentProjection.status, 'done');
+});
+
+test('runRuntimeAgenticWorkflow replans after terminal activity error', async () => {
+  const originalFetch = globalThis.fetch;
+  let pollAttempts = 0;
+  globalThis.fetch = async () => {
+    pollAttempts += 1;
+    return {
+      ok: true,
+      status: 200,
+      headers: { get: () => null },
+      text: async () => JSON.stringify({
+        result: {
+          content: [{ type: 'text', text: JSON.stringify({
+            _activity: {
+              id: 'job-failed',
+              source: 'production',
+              label: 'Production build',
+              status: 'error',
+              terminal: true,
+              error: 'build failed',
+            },
+          }) }],
+        },
+      }),
+    };
+  };
+  const session = {
+    mcp: {
+      production: {
+        status: 'connected',
+        url: 'http://127.0.0.1:3000/mcp/',
+        retry: { maxAttempts: 1, backoffMs: 0 },
+      },
+    },
+    activities: {},
+    headlessPlan: null,
+    llm: {
+      async completeWithTools({ system }) {
+        if (/replanner/.test(system)) return { content: '{"steps":["Retry build"]}' };
+        return { content: '{"ok":true,"reason":"Build complete.","suggestedAction":null}' };
+      },
+    },
+  };
+  let turns = 0;
+  const agent = {
+    async invoke({ session: turnSession }) {
+      turns += 1;
+      if (turns === 1) {
+        dispatchAgentEvent(turnSession, createAgentEvent('activity_upserted', {
+          payload: {
+            activity: {
+              id: 'job-failed',
+              source: 'production',
+              label: 'Production build',
+              status: 'running',
+              terminal: false,
+              poll: { server: 'production', tool: 'production_job_status', args: { jobId: 'job-failed' }, intervalMs: 0 },
+            },
+          },
+        }));
+        return { response: 'Started build.' };
+      }
+      if (turnSession.headlessPlan?.[0]?.status === 'pending') {
+        dispatchAgentEvent(turnSession, createAgentEvent('plan_step_updated', {
+          origin: 'tool',
+          payload: { step: 1, status: 'done' },
+        }));
+      }
+      return { response: 'Retry done.' };
+    },
+  };
+
+  try {
+    const result = await runRuntimeAgenticWorkflow(agent, session, 'Build workspace', {
+      runId: 'run-replan-activity',
+      timeoutMs: 1000,
+      maxTurns: 3,
+      maxReplans: 1,
+    });
+
+    assert.equal(result.ok, true);
+    assert.equal(pollAttempts, 1);
+    assert.equal(turns, 2);
+    assert.equal(session.agentProjection.replans[0].reason, 'Production build ended with error: build failed');
+    assert.deepEqual(session.agentProjection.replans[0].plan, ['Retry build']);
+    assert.equal(session.agentProjection.status, 'done');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('runRuntimeAgenticWorkflow stops after replan budget is exhausted', async () => {
+  const session = {
+    activities: {},
+    headlessPlan: null,
+    llm: {
+      async completeWithTools() {
+        return { content: '{"ok":false,"reason":"Still missing.","suggestedAction":"Try again."}' };
+      },
+    },
+  };
+  const agent = {
+    async invoke() {
+      return { response: 'Done.' };
+    },
+  };
+
+  const result = await runRuntimeAgenticWorkflow(agent, session, 'Do task', {
+    runId: 'run-replan-limit',
+    timeoutMs: 1000,
+    maxTurns: 1,
+    maxReplans: 0,
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.evaluationRejected, true);
+  assert.equal(session.agentProjection.status, 'error');
+  assert.equal(session.agentProjection.replans.length, 0);
+});