agentic-orchestrator 0.1.28 → 0.2.1

package/apps/control-plane/test/kernel-collision-replay.spec.ts

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { beforeEach, describe, expect, it } from 'vitest';
 import { AopKernel } from '../src/index.js';
-import { makeTempRepo, writeFeatureSpec } from './helpers.js';
+import { makeTempRepo, verifyFeatureIntake, writeFeatureSpec } from './helpers.js';
 
 const ORCHESTRATOR_CONTEXT = { actor_type: 'orchestrator', actor_id: 'test' };
 
@@ -54,6 +54,7 @@ async function initFeature(kernel: AopKernel, featureId: string) {
   await writeFeatureSpec(repoRoot, featureId);
   const init = await kernel.invoke('feature.init', { feature_id: featureId }, ORCHESTRATOR_CONTEXT);
   expect(init.ok).toBe(true);
+  await verifyFeatureIntake(kernel, featureId);
 }
 
 describe('AopKernel collision queue replay integration', () => {
@@ -239,5 +240,5 @@ describe('AopKernel collision queue replay integration', () => {
     expect(stateC.ok).toBe(true);
     expect(stateB.data.front_matter.version).toBeGreaterThan(1);
     expect(stateC.data.front_matter.version).toBeGreaterThan(1);
-  });
+  }, 20_000);
 });

package/apps/control-plane/test/kernel-tool-executor.spec.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it, vi } from 'vitest';
+import { fail, ok } from '../src/core/response.js';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+import { KernelToolExecutor } from '../src/mcp/kernel-tool-executor.js';
+import type { ToolCatalogEntry, VerifiedActorClaims } from '../src/mcp/runtime-types.js';
+
+const TOOL: ToolCatalogEntry = {
+  name: 'repo.reconcile_mainline',
+  description: 'Reconcile mainline',
+  input_schema_ref: 'schemas/input/repo.reconcile_mainline.input.schema.json',
+  output_schema_ref: 'schemas/output/repo.reconcile_mainline.output.schema.json',
+  supported_roles: ['orchestrator'],
+  handler_id: 'repo.reconcile_mainline',
+  mutating: true,
+  requires_operation_id: true,
+};
+
+const CLAIMS: VerifiedActorClaims = {
+  run_id: 'run:test',
+  session_id: 'session:test',
+  actor_type: 'orchestrator',
+  actor_id: 'dashboard',
+  issued_at: '2026-03-18T00:00:00.000Z',
+  expires_at: '2026-03-18T00:15:00.000Z',
+};
+
+describe('KernelToolExecutor', () => {
+  it('passes through successful ToolResponse envelopes unchanged', async () => {
+    const response = ok({
+      status: 'up_to_date',
+      divergence_detected: false,
+    });
+    const router = {
+      dispatchTool: vi.fn(async () => response),
+      normalizeError: vi.fn(),
+    };
+    const executor = new KernelToolExecutor(router);
+
+    await expect(executor.execute(TOOL, { feature_id: 'feature_x' }, CLAIMS)).resolves.toEqual(
+      response,
+    );
+  });
+
+  it('passes through failed ToolResponse envelopes unchanged', async () => {
+    const response = fail(ERROR_CODES.RECONCILIATION_FAILED, 'merge conflict', {
+      retryable: false,
+      requires_human: true,
+    });
+    const router = {
+      dispatchTool: vi.fn(async () => response),
+      normalizeError: vi.fn(),
+    };
+    const executor = new KernelToolExecutor(router);
+
+    await expect(executor.execute(TOOL, { feature_id: 'feature_x' }, CLAIMS)).resolves.toEqual(
+      response,
+    );
+  });
+
+  it('wraps plain handler payloads in ok envelopes for legacy handlers', async () => {
+    const router = {
+      dispatchTool: vi.fn(async () => ({
+        status: 'merged',
+        divergence_detected: true,
+      })),
+      normalizeError: vi.fn(),
+    };
+    const executor = new KernelToolExecutor(router);
+
+    await expect(executor.execute(TOOL, { feature_id: 'feature_x' }, CLAIMS)).resolves.toEqual(
+      ok({
+        status: 'merged',
+        divergence_detected: true,
+      }),
+    );
+  });
+});

package/apps/control-plane/test/kernel-tool-wiring.spec.ts

@@ -0,0 +1,279 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { KernelToolFacade } from '../src/application/kernel-tool-wiring.js';
+import { registerKernelTools } from '../src/application/kernel-tool-wiring.js';
+import { ToolHandlerRegistry } from '../src/application/tools/tool-router.js';
+
+function makeKernelFacade(): KernelToolFacade {
+  return {
+    repoReconcileMainline: vi.fn(async () => null),
+    featureDiscoverSpecs: vi.fn(async () => null),
+    featureInit: vi.fn(async () => null),
+    featureGetContext: vi.fn(async () => null),
+    featureStateGet: vi.fn(async () => null),
+    featureStatePatch: vi.fn(async () => null),
+    featureLogAppend: vi.fn(async () => null),
+    planSubmit: vi.fn(async () => null),
+    planGet: vi.fn(async () => null),
+    planUpdate: vi.fn(async () => null),
+    repoEnsureWorktree: vi.fn(async () => null),
+    repoApplyPatch: vi.fn(async () => null),
+    repoStatus: vi.fn(async () => null),
+    repoDiff: vi.fn(async () => null),
+    repoReadFile: vi.fn(async () => null),
+    repoSearch: vi.fn(async () => null),
+    repoDiffBundle: vi.fn(async () => null),
+    featureReadyToMerge: vi.fn(async () => null),
+    featureDelete: vi.fn(async () => null),
+    gatesList: vi.fn(async () => null),
+    gatesRun: vi.fn(async () => null),
+    evidenceLatest: vi.fn(async () => null),
+    qaTestIndexGet: vi.fn(async () => null),
+    qaTestIndexUpdate: vi.fn(async () => null),
+    locksAcquire: vi.fn(async () => null),
+    locksRelease: vi.fn(async () => null),
+    collisionsScan: vi.fn(async () => null),
+    reportDashboard: vi.fn(async () => null),
+    reportFeatureSummary: vi.fn(async () => null),
+    executionRequestSubmit: vi.fn(async () => null),
+    executionRequestList: vi.fn(async () => null),
+    featureSendMessage: vi.fn(async () => null),
+    featureQuestionCreate: vi.fn(async () => null),
+    featureQuestionList: vi.fn(async () => null),
+    featureQuestionAnswer: vi.fn(async () => null),
+    featureIntakeSubmit: vi.fn(async () => null),
+    costRecord: vi.fn(async () => null),
+    costGet: vi.fn(async () => null),
+    performanceRecordOutcome: vi.fn(async () => null),
+    performanceGetAnalytics: vi.fn(async () => null),
+    replayTimelineGet: vi.fn(async () => null),
+  };
+}
+
+describe('registerKernelTools', () => {
+  it('forwards remote_sync_strategy to featureReadyToMerge', async () => {
+    const registry = new ToolHandlerRegistry();
+    const kernel = makeKernelFacade();
+
+    registerKernelTools(registry, kernel);
+
+    const handler = registry.lookup('feature.ready_to_merge');
+    expect(handler).toBeDefined();
+
+    await handler(
+      {
+        feature_id: 'feature_merge',
+        commit_message: 'feat: merge feature_merge',
+        merge_strategy: 'merge_commit',
+        user_approval_token: 'approved',
+        remote_sync_strategy: 'auto',
+      },
+      { actorType: 'orchestrator', actorId: 'orch:test' },
+    );
+
+    expect(kernel.featureReadyToMerge).toHaveBeenCalledWith(
+      'feature_merge',
+      'feat: merge feature_merge',
+      'merge_commit',
+      'approved',
+      'auto',
+    );
+  });
+
+  it('forwards normalized question create fields to the kernel facade', async () => {
+    const registry = new ToolHandlerRegistry();
+    const kernel = makeKernelFacade();
+
+    registerKernelTools(registry, kernel);
+
+    const handler = registry.lookup('feature.question_create');
+    expect(handler).toBeDefined();
+
+    await handler(
+      {
+        feature_id: 'feature_q',
+        role: 'builder',
+        session_id: 'session-1',
+        question_type: 'external_decision',
+        prompt: 'Ship now?',
+        details: { area: 'deploy' },
+        expected_answer: { kind: 'single_choice', choices: ['yes', 'no'] },
+        blocking: true,
+        phase: 'building',
+        request_action: 'ask_user_input',
+      },
+      { actorType: 'orchestrator', actorId: 'orch:test' },
+    );
+
+    expect(kernel.featureQuestionCreate).toHaveBeenCalledWith({
+      feature_id: 'feature_q',
+      role: 'builder',
+      session_id: 'session-1',
+      question_type: 'external_decision',
+      prompt: 'Ship now?',
+      details: { area: 'deploy' },
+      expected_answer: { kind: 'single_choice', choices: ['yes', 'no'] },
+      blocking: true,
+      phase: 'building',
+      request_action: 'ask_user_input',
+    });
+  });
+
+  it('forwards question list and answer requests with fallback normalization', async () => {
+    const registry = new ToolHandlerRegistry();
+    const kernel = makeKernelFacade();
+
+    registerKernelTools(registry, kernel);
+
+    const listHandler = registry.lookup('feature.question_list');
+    const answerHandler = registry.lookup('feature.question_answer');
+    expect(listHandler).toBeDefined();
+    expect(answerHandler).toBeDefined();
+
+    await listHandler(
+      {
+        feature_id: 'feature_q',
+        status: 'all',
+      },
+      { actorType: 'orchestrator', actorId: 'orch:test' },
+    );
+    await answerHandler(
+      {
+        feature_id: 'feature_q',
+        question_id: 'q_1',
+        answer: 42,
+        answered_by: 'dashboard',
+      },
+      { actorType: 'orchestrator', actorId: 'orch:test' },
+    );
+
+    expect(kernel.featureQuestionList).toHaveBeenCalledWith('feature_q', 'all');
+    expect(kernel.featureQuestionAnswer).toHaveBeenCalledWith({
+      feature_id: 'feature_q',
+      question_id: 'q_1',
+      answer: '',
+      answered_by: 'dashboard',
+    });
+  });
+
+  it('forwards repo reconcile, runtime execution, and replay requests with handler defaults', async () => {
+    const registry = new ToolHandlerRegistry();
+    const kernel = makeKernelFacade();
+
+    registerKernelTools(registry, kernel);
+
+    const reconcileHandler = registry.lookup('repo.reconcile_mainline');
+    const submitHandler = registry.lookup('runtime.execution_request_submit');
+    const listHandler = registry.lookup('runtime.execution_request_list');
+    const replayHandler = registry.lookup('replay.timeline_get');
+    expect(reconcileHandler).toBeDefined();
+    expect(submitHandler).toBeDefined();
+    expect(listHandler).toBeDefined();
+    expect(replayHandler).toBeDefined();
+
+    await reconcileHandler(
+      {
+        feature_id: 'feature_q',
+        base_ref: 'origin/main',
+        auto_merge_non_conflicting: false,
+        remote_sync_strategy: 'auto',
+        commit_message: 'Checkpoint before merge',
+      },
+      { actorType: 'orchestrator', actorId: 'orch:test' },
+    );
+    await submitHandler(
+      {
+        run_id: 'run-1',
+        owner_instance_id: 'owner-1',
+        request_type: 'enqueue',
+        features: [{ feature_id: 'feature_q' }],
+        operation_id: 'op-1',
+      },
+      { actorType: 'orchestrator', actorId: 'orch:test' },
+    );
+    await listHandler({}, { actorType: 'orchestrator', actorId: 'orch:test' });
+    await replayHandler(
+      {
+        run_id: 'run-1',
+        feature_id: 'feature_q',
+        tool_name: 'feature.get_context',
+      },
+      { actorType: 'orchestrator', actorId: 'orch:test' },
+    );
+
+    expect(kernel.repoReconcileMainline).toHaveBeenCalledWith(
+      'feature_q',
+      'origin/main',
+      false,
+      'auto',
+      'Checkpoint before merge',
+    );
+    expect(kernel.executionRequestSubmit).toHaveBeenCalledWith({
+      run_id: 'run-1',
+      owner_instance_id: 'owner-1',
+      request_type: 'enqueue',
+      features: [{ feature_id: 'feature_q' }],
+      operation_id: 'op-1',
+    });
+    expect(kernel.executionRequestList).toHaveBeenCalledWith();
+    expect(kernel.replayTimelineGet).toHaveBeenCalledWith(
+      'run-1',
+      null,
+      null,
+      'feature_q',
+      'feature.get_context',
+    );
+  });
+
+  it('preserves structured answers and drops invalid optional question-create fields', async () => {
+    const registry = new ToolHandlerRegistry();
+    const kernel = makeKernelFacade();
+
+    registerKernelTools(registry, kernel);
+
+    const createHandler = registry.lookup('feature.question_create');
+    const answerHandler = registry.lookup('feature.question_answer');
+    expect(createHandler).toBeDefined();
+    expect(answerHandler).toBeDefined();
+
+    await createHandler(
+      {
+        feature_id: 'feature_q',
+        role: 'builder',
+        session_id: 'session-2',
+        prompt: 'Need structured approval?',
+        details: 'not-an-object',
+        expected_answer: 'also-not-an-object',
+        blocking: 'yes',
+      },
+      { actorType: 'orchestrator', actorId: 'orch:test' },
+    );
+    await answerHandler(
+      {
+        feature_id: 'feature_q',
+        question_id: 'q_2',
+        answer: { decision: 'approve' },
+        answered_by: 'dashboard',
+      },
+      { actorType: 'orchestrator', actorId: 'orch:test' },
+    );
+
+    expect(kernel.featureQuestionCreate).toHaveBeenCalledWith({
+      feature_id: 'feature_q',
+      role: 'builder',
+      session_id: 'session-2',
+      question_type: null,
+      prompt: 'Need structured approval?',
+      details: undefined,
+      expected_answer: undefined,
+      blocking: undefined,
+      phase: null,
+      request_action: null,
+    });
+    expect(kernel.featureQuestionAnswer).toHaveBeenCalledWith({
+      feature_id: 'feature_q',
+      question_id: 'q_2',
+      answer: { decision: 'approve' },
+      answered_by: 'dashboard',
+    });
+  });
+});

package/apps/control-plane/test/kernel.branches.spec.ts

@@ -5,7 +5,7 @@ import { AopKernel } from '../src/index.js';
 import { runGit } from '../src/core/git.js';
 import { ERROR_CODES } from '../src/core/error-codes.js';
 import { STATUS } from '../src/core/constants.js';
-import { makeTempRepo, writeFeatureSpec } from './helpers.js';
+import { makeTempRepo, verifyFeatureIntake, writeFeatureSpec } from './helpers.js';
 
 const ORCH = { actor_type: 'orchestrator', actor_id: 'orch:test' };
 const BUILDER = { actor_type: 'builder', actor_id: 'builder:test' };
@@ -103,6 +103,15 @@ describe('AopKernel branch behavior', () => {
     expect(forbiddenRoleTool.ok).toBe(false);
     expect(forbiddenRoleTool.error.code).toBe(ERROR_CODES.FORBIDDEN_TOOL_FOR_ROLE);
 
+    const plannerCanReadPlan = await kernel.invoke(
+      'plan.get',
+      { feature_id: 'x' },
+      { actor_type: 'planner', actor_id: 'planner:test' },
+    );
+    expect(plannerCanReadPlan.ok ? null : plannerCanReadPlan.error.code).not.toBe(
+      ERROR_CODES.FORBIDDEN_TOOL_FOR_ROLE,
+    );
+
     const missingFeatureId = await kernel.invoke('feature.init', {}, ORCH);
     expect(missingFeatureId.ok).toBe(false);
     expect(missingFeatureId.error.code).toBe(ERROR_CODES.INVALID_ARGUMENT);
@@ -111,6 +120,8 @@ describe('AopKernel branch behavior', () => {
     await writeFeatureSpec(repoRoot, 'feature_b');
     await kernel.invoke('feature.init', { feature_id: 'feature_a' }, ORCH);
     await kernel.invoke('feature.init', { feature_id: 'feature_b' }, ORCH);
+    await verifyFeatureIntake(kernel, 'feature_a');
+    await verifyFeatureIntake(kernel, 'feature_b');
 
     const invalidSchema = await kernel.invoke(
       'plan.submit',
@@ -189,6 +200,7 @@ describe('AopKernel branch behavior', () => {
     await writeFeatureSpec(repoRoot, 'feature_c');
     await writeFeatureSpec(repoRoot, 'feature_uninit');
     await kernel.invoke('feature.init', { feature_id: 'feature_c' }, ORCH);
+    await verifyFeatureIntake(kernel, 'feature_c');
 
     const noPlanPatch = await kernel.invoke(
       'repo.apply_patch',
@@ -270,13 +282,14 @@ describe('AopKernel branch behavior', () => {
     );
     expect(blockedState.ok).toBe(true);
     expect(blockedState.data.front_matter.status).toBe(STATUS.BLOCKED);
-  });
+  }, 20_000);
 
   it('covers merge precondition branches for status and required gate modes', async () => {
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
     await writeFeatureSpec(repoRoot, 'feature_merge');
     await kernel.invoke('feature.init', { feature_id: 'feature_merge' }, ORCH);
+    await verifyFeatureIntake(kernel, 'feature_merge');
     await kernel.invoke(
       'plan.submit',
       { feature_id: 'feature_merge', plan_json: validPlan('feature_merge') },

package/apps/control-plane/test/kernel.coverage.spec.ts

@@ -5,7 +5,7 @@ import { AopKernel } from '../src/index.js';
 import { ERROR_CODES } from '../src/core/error-codes.js';
 import { STATUS } from '../src/core/constants.js';
 import { runGit } from '../src/core/git.js';
-import { makeTempRepo, writeFeatureSpec } from './helpers.js';
+import { makeTempRepo, verifyFeatureIntake, writeFeatureSpec } from './helpers.js';
 
 let repoRoot: string;
 
@@ -91,6 +91,8 @@ describe('AopKernel additional coverage', () => {
 
     await kernel.invoke('feature.init', { feature_id: 'feature_cov' }, ORCHESTRATOR_CONTEXT);
     await kernel.invoke('feature.init', { feature_id: 'feature_other' }, ORCHESTRATOR_CONTEXT);
+    await verifyFeatureIntake(kernel, 'feature_cov');
+    await verifyFeatureIntake(kernel, 'feature_other');
 
     const logResult = await kernel.invoke(
       'feature.log_append',
@@ -327,7 +329,7 @@ describe('AopKernel additional coverage', () => {
     );
     expect(gateUnknown.ok).toBe(false);
     expect(gateUnknown.error.code).toBe(ERROR_CODES.UNKNOWN_GATE_PROFILE_OR_MODE);
-  });
+  }, 20_000);
 
   it('queues collisions when policy is set to block and executes lease wrapper methods', async () => {
     const kernel = new AopKernel(repoRoot);
@@ -337,6 +339,8 @@ describe('AopKernel additional coverage', () => {
 
     await kernel.invoke('feature.init', { feature_id: 'feature_a' }, ORCHESTRATOR_CONTEXT);
     await kernel.invoke('feature.init', { feature_id: 'feature_b' }, ORCHESTRATOR_CONTEXT);
+    await verifyFeatureIntake(kernel, 'feature_a');
+    await verifyFeatureIntake(kernel, 'feature_b');
 
     kernel.policy.collision_policy = 'block';
 
@@ -403,7 +407,7 @@ describe('AopKernel additional coverage', () => {
 
     const released = await kernel.releaseRunLease('run:coverage', 'owner:coverage');
     expect(released.data.released).toBe(true);
-  });
+  }, 20_000);
 
   it('normalizes known and unknown errors into stable error envelopes', async () => {
     const kernel = new AopKernel(repoRoot);