agentic-orchestrator 0.1.17 → 0.1.19

package/agentic/orchestrator/prompts/planner.system.md

@@ -2,6 +2,7 @@ You are the planner role.
 
 Produce deterministic plan submissions and plan updates that conform to plan schema and policy constraints.
 Avoid speculative edits outside the declared file scope.
+When emitting `PLAN_SUBMISSION` or `REQUEST.action=amend_plan`, `plan_json` must only include keys allowed by `plan.schema.json` (no extra fields such as `phase_notes`).
 
 After each QA wave, perform an explicit reconciliation pass:
 

package/apps/control-plane/src/providers/cli-worker-provider.ts

@@ -30,6 +30,9 @@ interface CommandTemplateValues {
   message?: string;
 }
 
+const CLAUDE_MIN_EFFECTIVE_TIMEOUT_MS = 300_000;
+const HISTORICAL_DEFAULT_TIMEOUT_MS = 120_000;
+
 function buildStructuredWorkerPrompt(payload: Record<string, unknown>): string {
   return [
     'Return exactly one JSON object and nothing else.',
@@ -301,14 +304,15 @@ export class CliWorkerProvider implements WorkerProvider {
       featureId: input.feature_id,
       role: input.role,
     });
+    const effectiveTimeoutMs = this.resolveRunTimeoutMs();
 
     const runResult = await this.commandRunner.run(this.runTemplate.command, args, {
       stdin: prompt,
-      timeoutMs: this.workerResponseTimeoutMs,
+      timeoutMs: effectiveTimeoutMs,
       env: buildRunCommandEnv(this.selection),
     });
 
-    this.ensureRunSucceeded(runResult, this.runTemplate.command, args);
+    this.ensureRunSucceeded(runResult, this.runTemplate.command, args, effectiveTimeoutMs);
 
     return this.outputParser.parse(runResult.stdout ?? '', {
       sessionId,
@@ -323,7 +327,12 @@ export class CliWorkerProvider implements WorkerProvider {
     return `${role}::${featureId}`;
   }
 
-  private ensureRunSucceeded(result: ProviderCommandResult, command: string, args: string[]): void {
+  private ensureRunSucceeded(
+    result: ProviderCommandResult,
+    command: string,
+    args: string[],
+    timeoutMs: number,
+  ): void {
     if (result.exitCode === 0) {
       return;
     }
@@ -338,11 +347,24 @@ export class CliWorkerProvider implements WorkerProvider {
         exit_code: result.exitCode,
         signal: result.signal,
         error_code: result.errorCode,
+        timed_out: result.timedOut ?? false,
+        timeout_ms: timeoutMs,
         stderr: result.stderr,
       },
     );
   }
 
+  private resolveRunTimeoutMs(): number {
+    if (
+      this.selection.provider === 'claude' &&
+      this.workerResponseTimeoutMs >= HISTORICAL_DEFAULT_TIMEOUT_MS &&
+      this.workerResponseTimeoutMs < CLAUDE_MIN_EFFECTIVE_TIMEOUT_MS
+    ) {
+      return CLAUDE_MIN_EFFECTIVE_TIMEOUT_MS;
+    }
+    return this.workerResponseTimeoutMs;
+  }
+
   private async executeControlCommand(
     kind: 'attach' | 'send',
     sessionId: string,

package/apps/control-plane/src/providers/providers.ts

@@ -242,6 +242,7 @@ export interface ProviderCommandResult {
   exitCode: number;
   signal: NodeJS.Signals | null;
   errorCode?: number | string;
+  timedOut?: boolean;
   stdout?: string;
   stderr?: string;
 }
@@ -309,8 +310,10 @@ export class NodeProviderCommandRunner implements ProviderCommandRunner {
       }
 
       let timeoutHandle: NodeJS.Timeout | null = null;
+      let killedByTimeout = false;
       if (!options.interactive && typeof options.timeoutMs === 'number' && options.timeoutMs > 0) {
         timeoutHandle = setTimeout(() => {
+          killedByTimeout = true;
           child.kill('SIGKILL');
         }, options.timeoutMs);
       }
@@ -323,6 +326,7 @@ export class NodeProviderCommandRunner implements ProviderCommandRunner {
           exitCode: code ?? (spawnErrorCode === 'ENOENT' ? 127 : 1),
           signal,
           errorCode: spawnErrorCode,
+          timedOut: killedByTimeout,
           stdout,
           stderr,
         });

package/apps/control-plane/src/supervisor/worker-decision-loop.ts

@@ -7,6 +7,23 @@ import type { RuntimeRole, SupervisorToolCaller } from './types.js';
 import type { ActivityMonitorService } from '../application/services/activity-monitor-service.js';
 
 type AnyRecord = Record<string, unknown>;
+const PLAN_TOP_LEVEL_KEYS = new Set([
+  'feature_id',
+  'plan_version',
+  'summary',
+  'allowed_areas',
+  'forbidden_areas',
+  'base_ref',
+  'files',
+  'contracts',
+  'acceptance_criteria',
+  'gate_profile',
+  'gate_targets',
+  'risk',
+  'revision_of',
+  'revision_reason',
+  'verification_overrides',
+]);
 
 export interface WorkerDecisionInput {
   role: RuntimeRole;
@@ -65,6 +82,17 @@ function readPlanVersion(value: unknown): number | null {
   return Math.floor(value);
 }
 
+function sanitizePlannerPlan(plan: AnyRecord): AnyRecord {
+  const sanitized: AnyRecord = {};
+  for (const [key, value] of Object.entries(plan)) {
+    if (!PLAN_TOP_LEVEL_KEYS.has(key)) {
+      continue;
+    }
+    sanitized[key] = value;
+  }
+  return sanitized;
+}
+
 function asOutputs(result: Record<string, unknown>): AnyRecord[] {
   const outputs = result.outputs;
   if (Array.isArray(outputs)) {
@@ -223,7 +251,7 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
       return;
     }
 
-    const planJson = asRecord(output.plan_json ?? output.plan);
+    const planJson = sanitizePlannerPlan(asRecord(output.plan_json ?? output.plan));
     if (Object.keys(planJson).length === 0) {
       return;
     }
@@ -350,7 +378,7 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
     }
 
     if (action === 'amend_plan' && input.role === 'planner') {
-      const planJson = asRecord(request.plan_json);
+      const planJson = sanitizePlannerPlan(asRecord(request.plan_json));
       if (Object.keys(planJson).length === 0) {
         return;
       }

package/apps/control-plane/test/dashboard-api.integration.spec.ts

@@ -11,6 +11,12 @@ const readDashboardStatusMock = vi.hoisted(() =>
   })),
 );
 const readFeatureStateMock = vi.hoisted(() => vi.fn(async () => null));
+const readFeatureLogMock = vi.hoisted(() =>
+  vi.fn(async () => ({
+    entries: [{ timestamp: '2026-03-05T00:00:00Z', message: 'log message', type: 'log' }],
+    total: 1,
+  })),
+);
 const getAopRootMock = vi.hoisted(() => vi.fn(() => process.cwd()));
 const approveFeatureReviewMock = vi.hoisted(() =>
   vi.fn(async () => ({ ok: true, data: { merged: true } })),
@@ -21,12 +27,19 @@ const denyFeatureReviewMock = vi.hoisted(() =>
 const requestFeatureChangesMock = vi.hoisted(() =>
   vi.fn(async () => ({ ok: true, data: { delivered: true } })),
 );
+const sendFeatureMessageMock = vi.hoisted(() =>
+  vi.fn(async () => ({ ok: true, data: { delivered: true } })),
+);
+const retryFeatureMock = vi.hoisted(() =>
+  vi.fn(async () => ({ ok: true, data: { retry_mode: 'full' } })),
+);
 const execFileMock = vi.hoisted(() => vi.fn());
 
 vi.mock('../../../packages/web-dashboard/src/lib/aop-client.js', () => ({
   resolveProjectRoot: resolveProjectRootMock,
   readDashboardStatus: readDashboardStatusMock,
   readFeatureState: readFeatureStateMock,
+  readFeatureLog: readFeatureLogMock,
   getAopRoot: getAopRootMock,
 }));
 
@@ -34,6 +47,8 @@ vi.mock('../../../packages/web-dashboard/src/lib/orchestrator-tools.js', () => (
   approveFeatureReview: approveFeatureReviewMock,
   denyFeatureReview: denyFeatureReviewMock,
   requestFeatureChanges: requestFeatureChangesMock,
+  sendFeatureMessage: sendFeatureMessageMock,
+  retryFeature: retryFeatureMock,
 }));
 
 vi.mock('node:child_process', () => ({
@@ -52,6 +67,7 @@ vi.mock('node:child_process', () => ({
 
 import { POST as actionsPost } from '../../../packages/web-dashboard/src/app/api/actions/route.js';
 import { POST as checkoutPost } from '../../../packages/web-dashboard/src/app/api/features/[id]/checkout/route.js';
+import { GET as logGet } from '../../../packages/web-dashboard/src/app/api/features/[id]/log/route.js';
 import { GET as statusGet } from '../../../packages/web-dashboard/src/app/api/status/route.js';
 import { GET as projectsGet } from '../../../packages/web-dashboard/src/app/api/projects/route.js';
 
@@ -67,10 +83,13 @@ describe('dashboard api integration', () => {
     resolveProjectRootMock.mockReset();
     readDashboardStatusMock.mockReset();
     readFeatureStateMock.mockReset();
+    readFeatureLogMock.mockReset();
     getAopRootMock.mockReset();
     approveFeatureReviewMock.mockReset();
     denyFeatureReviewMock.mockReset();
     requestFeatureChangesMock.mockReset();
+    sendFeatureMessageMock.mockReset();
+    retryFeatureMock.mockReset();
     execFileMock.mockReset();
 
     resolveProjectRootMock.mockResolvedValue(repoRoot);
@@ -89,6 +108,10 @@ describe('dashboard api integration', () => {
         },
       ],
     });
+    readFeatureLogMock.mockResolvedValue({
+      entries: [{ timestamp: '2026-03-05T00:00:00Z', message: 'log message', type: 'log' }],
+      total: 1,
+    });
   });
 
   afterEach(async () => {
@@ -154,6 +177,58 @@ describe('dashboard api integration', () => {
     expect(body.error.code).toBe('reason_required');
   });
 
+  it('GIVEN_feature_send_message_without_message_WHEN_posted_THEN_returns_400', async () => {
+    const response = await actionsPost(
+      new Request('http://localhost/api/actions', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'feature.send_message',
+          feature_id: 'feature_checkout',
+        }),
+      }),
+    );
+
+    const body = (await response.json()) as { ok: boolean; error: { code: string } };
+    expect(response.status).toBe(400);
+    expect(body.ok).toBe(false);
+    expect(body.error.code).toBe('message_required');
+  });
+
+  it('GIVEN_feature_send_message_WHEN_posted_THEN_routes_to_tool', async () => {
+    const response = await actionsPost(
+      new Request('http://localhost/api/actions?project=alpha', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'feature.send_message',
+          feature_id: 'feature_checkout',
+          message: 'Need clarification',
+        }),
+      }),
+    );
+
+    expect(response.status).toBe(200);
+    expect(sendFeatureMessageMock).toHaveBeenCalledWith(
+      'feature_checkout',
+      'Need clarification',
+      repoRoot,
+    );
+  });
+
+  it('GIVEN_feature_retry_WHEN_posted_THEN_routes_to_retry_tool', async () => {
+    const response = await actionsPost(
+      new Request('http://localhost/api/actions', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'feature.retry',
+          feature_id: 'feature_checkout',
+        }),
+      }),
+    );
+
+    expect(response.status).toBe(200);
+    expect(retryFeatureMock).toHaveBeenCalledWith('feature_checkout', repoRoot);
+  });
+
   it('GIVEN_checkout_then_restore_WHEN_feature_branch_exists_THEN_persists_and_restores_checkout_record', async () => {
     readFeatureStateMock.mockResolvedValue({
       id: 'feature_checkout',
@@ -276,4 +351,23 @@ describe('dashboard api integration', () => {
     expect(body.data.projects.map((project) => project.name)).toEqual(['alpha', 'beta']);
     expect(body.data.projects.map((project) => project.path)).toEqual([projectAlpha, projectBeta]);
   });
+
+  it('GIVEN_feature_history_route_WHEN_requested_THEN_returns_log_entries', async () => {
+    const response = await logGet(
+      new Request('http://localhost/api/features/feature_checkout/log?project=alpha'),
+      {
+        params: Promise.resolve({ id: 'feature_checkout' }),
+      },
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data: { entries: Array<{ message: string }>; total: number };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.data.total).toBe(1);
+    expect(body.data.entries[0].message).toBe('log message');
+    expect(readFeatureLogMock).toHaveBeenCalledWith('feature_checkout', repoRoot);
+  });
 });

package/apps/control-plane/test/dashboard-client.spec.ts

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { afterEach, describe, expect, it } from 'vitest';
-import { readDashboardStatus } from '@/lib/aop-client.js';
+import { readDashboardStatus, readFeatureLog } from '@/lib/aop-client.js';
 
 async function writeState(repoRoot: string, featureId: string, frontMatter: string): Promise<void> {
   const featureDir = path.join(repoRoot, '.aop', 'features', featureId);
@@ -91,6 +91,33 @@ describe('dashboard aop client mapping', () => {
     });
   });
 
+  it('GIVEN_state_with_gate_map_WHEN_readDashboardStatus_THEN_gate_statuses_are_parsed', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-dash-client-'));
+    tempRoots.push(repoRoot);
+    await fs.mkdir(path.join(repoRoot, '.aop', 'features'), { recursive: true });
+    await fs.writeFile(
+      path.join(repoRoot, '.aop', 'features', 'index.json'),
+      JSON.stringify({ active: ['feature_gate'], blocked: [], merged: [], blocked_queue: [] }),
+      'utf8',
+    );
+    await writeState(
+      repoRoot,
+      'feature_gate',
+      [
+        'feature_id: feature_gate',
+        'version: 1',
+        'status: qa',
+        'gates:',
+        '  fast: pass',
+        '  full: fail',
+        '  merge: na',
+      ].join('\n'),
+    );
+
+    const payload = await readDashboardStatus(repoRoot);
+    expect(payload.features[0].gates).toEqual({ fast: 'pass', full: 'fail', merge: 'na' });
+  });
+
   it('GIVEN_blocked_queue_feature_without_state_WHEN_readDashboardStatus_THEN_phase_is_blocked', async () => {
     const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-dash-client-'));
     tempRoots.push(repoRoot);
@@ -119,4 +146,31 @@ describe('dashboard aop client mapping', () => {
       phase: 'blocked',
     });
   });
+
+  it('GIVEN_state_body_and_evidence_WHEN_readFeatureLog_THEN_returns_sorted_entries', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-dash-client-'));
+    tempRoots.push(repoRoot);
+    const featureRoot = path.join(repoRoot, '.aop', 'features', 'feature_hist');
+    const evidenceRoot = path.join(featureRoot, 'evidence');
+    await fs.mkdir(evidenceRoot, { recursive: true });
+    await fs.writeFile(
+      path.join(featureRoot, 'state.md'),
+      [
+        '---',
+        'feature_id: feature_hist',
+        'status: qa',
+        '---',
+        '[2026-03-05T00:00:00Z] status changed to qa',
+        '[2026-03-04T20:00:00Z] gates fast pass',
+      ].join('\n'),
+      'utf8',
+    );
+    await fs.writeFile(path.join(evidenceRoot, 'qa-summary.txt'), 'ok', 'utf8');
+
+    const log = await readFeatureLog('feature_hist', repoRoot);
+    expect(log.total).toBeGreaterThanOrEqual(3);
+    expect(log.entries[0].timestamp >= log.entries[1].timestamp).toBe(true);
+    expect(log.entries.some((entry) => entry.type === 'evidence')).toBe(true);
+    expect(log.entries.some((entry) => entry.type === 'state_change')).toBe(true);
+  });
 });

package/apps/control-plane/test/dashboard-ui-utils.spec.ts

@@ -0,0 +1,139 @@
+import { describe, expect, it } from 'vitest';
+import {
+  applyQuickFilter,
+  computeSummaryCounts,
+  createDefaultFilters,
+  filterFeatures,
+  formatElapsedTime,
+  formatRelativeTime,
+  parseUnifiedDiff,
+  truncateText,
+} from '../../../packages/web-dashboard/src/lib/dashboard-utils.js';
+import type {
+  DashboardStatusPayload,
+  FeatureSummary,
+} from '../../../packages/web-dashboard/src/lib/types.js';
+
+function feature(overrides: Partial<FeatureSummary>): FeatureSummary {
+  return {
+    id: overrides.feature_id ?? 'feature_a',
+    feature_id: overrides.feature_id ?? 'feature_a',
+    status: overrides.status ?? 'planning',
+    phase: overrides.phase ?? 'planning',
+    branch: overrides.branch ?? null,
+    worktree_path: overrides.worktree_path ?? null,
+    activity_state: overrides.activity_state ?? 'idle',
+    pr: overrides.pr ?? null,
+    gates: overrides.gates,
+    ...overrides,
+  };
+}
+
+describe('dashboard utilities', () => {
+  it('applies quick filters deterministically', () => {
+    const active = applyQuickFilter('active');
+    expect(active.phases).toEqual(['planning', 'building', 'qa', 'ready_to_merge']);
+
+    const awaitingInput = applyQuickFilter('awaiting_input');
+    expect(awaitingInput.activities).toEqual(['waiting_input']);
+
+    const ciFailing = applyQuickFilter('ci_failing');
+    expect(ciFailing.ciFailuresOnly).toBe(true);
+  });
+
+  it('filters feature collections by search, phase, activity, gates, and ci', () => {
+    const features = [
+      feature({
+        feature_id: 'alpha',
+        phase: 'blocked',
+        activity_state: 'waiting_input',
+        gates: { fast: 'fail' },
+        pr: { ci_status: 'failure' },
+      }),
+      feature({
+        feature_id: 'beta',
+        phase: 'qa',
+        activity_state: 'active',
+        gates: { fast: 'pass' },
+        pr: { ci_status: 'success' },
+      }),
+    ];
+
+    const filters = {
+      ...createDefaultFilters(),
+      searchText: 'alp',
+      phases: ['blocked'] as FeatureSummary['phase'][],
+      activities: ['waiting_input'] as NonNullable<FeatureSummary['activity_state']>[],
+      gateFailuresOnly: true,
+      ciFailuresOnly: true,
+    };
+
+    const filtered = filterFeatures(features, filters);
+    expect(filtered).toHaveLength(1);
+    expect(filtered[0].feature_id).toBe('alpha');
+  });
+
+  it('computes summary counters from status payload', () => {
+    const payload: DashboardStatusPayload = {
+      index: {
+        active: ['alpha', 'beta'],
+        blocked: ['alpha'],
+        merged: [],
+        blocked_queue: [],
+      },
+      features: [
+        feature({
+          feature_id: 'alpha',
+          phase: 'blocked',
+          activity_state: 'waiting_input',
+          pr: { ci_status: 'failure' },
+        }),
+        feature({
+          feature_id: 'beta',
+          phase: 'ready_to_merge',
+          activity_state: 'active',
+          pr: { ci_status: 'success' },
+        }),
+      ],
+    };
+
+    const counts = computeSummaryCounts(payload);
+    expect(counts).toEqual({
+      active: 2,
+      blocked: 1,
+      awaitingInput: 1,
+      readyToMerge: 1,
+      ciFailing: 1,
+    });
+  });
+
+  it('parses unified diff into file and hunk metadata with line numbers', () => {
+    const parsed = parseUnifiedDiff(
+      [
+        'diff --git a/file.ts b/file.ts',
+        'index abc..def 100644',
+        '--- a/file.ts',
+        '+++ b/file.ts',
+        '@@ -1,2 +1,2 @@',
+        '-const oldValue = 1;',
+        '+const newValue = 2;',
+        ' export const done = true;',
+      ].join('\n'),
+    );
+
+    expect(parsed).toHaveLength(1);
+    expect(parsed[0].filePath).toBe('file.ts');
+    const allLines = parsed[0].hunks.flatMap((hunk) => hunk.lines);
+    const firstDelete = allLines.find((line) => line.type === 'del');
+    const firstAdd = allLines.find((line) => line.type === 'add');
+    expect(firstDelete).toMatchObject({ type: 'del', oldLineNumber: 1 });
+    expect(firstAdd).toMatchObject({ type: 'add', newLineNumber: 1 });
+  });
+
+  it('formats relative and elapsed time and truncates text', () => {
+    const now = Date.parse('2026-03-05T00:01:00Z');
+    expect(formatRelativeTime('2026-03-05T00:00:00Z', now)).toBe('1 minute ago');
+    expect(formatElapsedTime('2026-03-04T22:31:00Z', now)).toBe('1h 30m');
+    expect(truncateText('feature_abcdefghijklmnopqrstuvwxyz', 24)).toBe('feature_abcdefghijklm...');
+  });
+});

package/apps/control-plane/test/providers.spec.ts

@@ -689,5 +689,6 @@ describe('NodeProviderCommandRunner', () => {
     const result = await runner.run('sleep', ['10'], { timeoutMs: 50 });
     // Killed by SIGKILL → exitCode should be non-zero or null
     expect(result.signal).toBe('SIGKILL');
+    expect(result.timedOut).toBe(true);
   });
 });

package/apps/control-plane/test/worker-decision-loop.spec.ts

@@ -19,7 +19,7 @@ describe('WorkerDecisionLoop', () => {
 
   function makeToolCaller() {
     return {
-      callTool: vi.fn(async (_role: string, toolName: string) => {
+      callTool: vi.fn(async (_role: string, toolName: string, _input?: unknown) => {
         if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
           return { ok: true, data: { refreshed: true } };
         }
@@ -117,6 +117,38 @@ describe('WorkerDecisionLoop', () => {
     );
   });
 
+  it('GIVEN_planner_submission_with_unknown_plan_fields_WHEN_executed_THEN_drops_unrecognized_fields', async () => {
+    const provider = makeProvider({
+      type: 'PLAN_SUBMISSION',
+      plan_json: {
+        feature_id: 'feature_a',
+        plan_version: 1,
+        summary: 'Initial plan',
+        phase_notes: ['not in schema'],
+      },
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: { plan: null },
+      instructions: 'plan',
+    });
+
+    expect(result.planSubmission).toBe(true);
+    const planSubmitCall = toolCaller.callTool.mock.calls.find(
+      (call) => call[0] === 'planner' && call[1] === TOOLS.PLAN_SUBMIT,
+    );
+    expect(planSubmitCall).toBeDefined();
+    const payload = planSubmitCall?.[2] as { plan_json?: Record<string, unknown> };
+    expect(payload.plan_json?.phase_notes).toBeUndefined();
+  });
+
   it('GIVEN_planner_submission_with_existing_plan_WHEN_executed_THEN_routes_to_plan_update', async () => {
     const provider = makeProvider({
       type: 'PLAN_SUBMISSION',
@@ -478,6 +510,42 @@ describe('WorkerDecisionLoop', () => {
     );
   });
 
+  it('GIVEN_planner_amend_plan_with_unknown_plan_fields_WHEN_executed_THEN_strips_unrecognized_fields', async () => {
+    const provider = makeProvider({
+      type: 'REQUEST',
+      request: {
+        action: 'amend_plan',
+        plan_json: {
+          feature_id: 'feature_a',
+          plan_version: 1,
+          summary: 'Plan with extra metadata',
+          phase_notes: ['drop me'],
+        },
+      },
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: { plan: null },
+      instructions: 'amend',
+    });
+
+    expect(result.requestHandled).toBe(true);
+    expect(result.planSubmission).toBe(true);
+    const planSubmitCall = toolCaller.callTool.mock.calls.find(
+      (call) => call[0] === 'planner' && call[1] === TOOLS.PLAN_SUBMIT,
+    );
+    expect(planSubmitCall).toBeDefined();
+    const payload = planSubmitCall?.[2] as { plan_json?: Record<string, unknown> };
+    expect(payload.plan_json?.phase_notes).toBeUndefined();
+  });
+
   it('GIVEN_planner_amend_plan_request_WHEN_existing_version_present_THEN_updates_plan', async () => {
     const provider = makeProvider({
       type: 'REQUEST',
@@ -620,7 +688,7 @@ describe('WorkerDecisionLoop amend_plan revision_of branches', () => {
 
   function makeToolCaller() {
     return {
-      callTool: vi.fn(async (_role: string, toolName: string) => {
+      callTool: vi.fn(async (_role: string, toolName: string, _input?: unknown) => {
         if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
           return { ok: true, data: { refreshed: true } };
         }

package/apps/control-plane/test/worker-provider-adapters.spec.ts

@@ -323,6 +323,40 @@ describe('CliWorkerProvider', () => {
     expect(options?.stdin).toContain('"feature_id":"feature-a"');
   });
 
+  it('GIVEN_claude_with_legacy_default_timeout_WHEN_runWorker_THEN_uses_extended_effective_timeout', async () => {
+    const run = vi.fn(
+      async (
+        _command: string,
+        _args: string[],
+        _options?: Record<string, unknown>,
+      ): Promise<ProviderCommandResult> => ({
+        exitCode: 0,
+        signal: null,
+        stdout: JSON.stringify({
+          outputs: [{ type: 'NOTE', content: 'ok' }],
+        }),
+      }),
+    );
+
+    const provider = new CliWorkerProvider(makeSelection('claude'), {
+      outputParser: new GenericCliOutputParser(),
+      commandRunner: { run },
+      workerResponseTimeoutMs: 120_000,
+    });
+
+    await provider.createSession('planner', 'feature-timeout', 'prompt');
+    await provider.runWorker({
+      role: 'planner',
+      feature_id: 'feature-timeout',
+    });
+
+    const firstCall = run.mock.calls.at(0);
+    const options = firstCall?.[2] as
+      | { stdin?: string; timeoutMs?: number; env?: NodeJS.ProcessEnv }
+      | undefined;
+    expect(options?.timeoutMs).toBe(300_000);
+  });
+
   it('GIVEN_nonzero_run_exit_WHEN_runWorker_THEN_throws_runtime_unavailable', async () => {
     const provider = new CliWorkerProvider(makeSelection('codex'), {
       outputParser: new GenericCliOutputParser(),

package/config/agentic/orchestrator/agents.yaml

@@ -11,6 +11,6 @@ runtime:
   default_provider: claude
   default_model: local-default
   worker_provider_mode: live
-  worker_response_timeout_ms: 120000
+  worker_response_timeout_ms: 300000
   max_consecutive_no_progress_iterations: 2
   role_provider_overrides: {}