agentic-orchestrator 0.1.28 → 0.2.1

package/apps/control-plane/src/core/kernel.ts

@@ -36,11 +36,13 @@ import { ReportingService } from '../application/services/reporting-service.js';
 import { FeatureStateService } from '../application/services/feature-state-service.js';
 import { FeatureLifecycleService } from '../application/services/feature-lifecycle-service.js';
 import { PlanService } from '../application/services/plan-service.js';
-import { PatchService, type PatchValidationResult } from '../application/services/patch-service.js';
+import { PatchService } from '../application/services/patch-service.js';
 import { GateService } from '../application/services/gate-service.js';
 import { QaIndexService } from '../application/services/qa-index-service.js';
 import { MergeService } from '../application/services/merge-service.js';
+import { GitReconciliationService } from '../application/services/git-reconciliation-service.js';
 import { CollisionQueueService } from '../application/services/collision-queue-service.js';
+import { CollisionOverrideService } from '../application/services/collision-override-service.js';
 import {
   FeatureDeletionService,
   type FeatureDeleteResult,
@@ -50,7 +52,10 @@ import {
   PerformanceAnalyticsService,
   type FeatureOutcome,
 } from '../application/services/performance-analytics-service.js';
+import { ExecutionControlService } from '../application/services/execution-control-service.js';
 import { GateSelectionService } from '../application/services/gate-selection-service.js';
+import { QuestionService } from '../application/services/question-service.js';
+import { IntakeService } from '../application/services/intake-service.js';
 import type { WorkerProvider } from '../providers/providers.js';
 import type {
   AnyRecord,
@@ -72,6 +77,14 @@ import { ConfigurationService } from '../application/configuration-service.js';
 import { RepoOperationsService } from '../application/services/repo-operations-service.js';
 import { FeatureSendMessageService } from '../application/services/feature-send-message-service.js';
 import { registerKernelTools } from '../application/kernel-tool-wiring.js';
+import { ReplayTimelineService } from '../application/services/replay-timeline-service.js';
+import type {
+  ExecutionRequestItem,
+  ExecutionRequestOutcome,
+  ExecutionRequestStatus,
+  PendingExecutionRequestProgress,
+} from './execution-control.js';
+import type { QuestionStatus } from './questions.js';
 
 /**
  * Deterministic orchestration kernel for multi-agent feature development.
@@ -122,6 +135,7 @@ export class AopKernel {
   private readonly runLeaseService: RunLeaseService;
   private readonly lockService: LockService;
   readonly collisionQueueService: CollisionQueueService;
+  private readonly collisionOverrideService: CollisionOverrideService;
   private readonly reportingService: ReportingService;
   private readonly featureStateService: FeatureStateService;
   private readonly featureLifecycleService: FeatureLifecycleService;
@@ -130,12 +144,17 @@ export class AopKernel {
   private readonly gateService: GateService;
   private readonly qaIndexService: QaIndexService;
   private readonly mergeService: MergeService;
+  readonly gitReconciliationService: GitReconciliationService;
   private readonly featureDeletionService: FeatureDeletionService;
   private readonly costTrackingService: CostTrackingService;
   private readonly performanceAnalyticsService: PerformanceAnalyticsService;
+  private readonly executionControlService: ExecutionControlService;
   private readonly gateSelectionService: GateSelectionService;
+  private readonly questionService: QuestionService;
+  private readonly intakeService: IntakeService;
   private readonly repoOperationsService: RepoOperationsService;
   private readonly sendMessageService: FeatureSendMessageService;
+  private readonly replayTimelineService: ReplayTimelineService;
   private readonly pathLayout: AopPathLayout;
   readonly instanceId: string;
   private provider: WorkerProvider | null = null;
@@ -168,6 +187,7 @@ export class AopKernel {
     registerKernelTools(this.toolHandlers, this);
     this.runLeaseService = new RunLeaseService(this);
     this.collisionQueueService = new CollisionQueueService(this);
+    this.collisionOverrideService = new CollisionOverrideService(this);
     this.lockService = new LockService(this);
     this.reportingService = new ReportingService(this);
     this.featureStateService = new FeatureStateService(this);
@@ -177,16 +197,21 @@ export class AopKernel {
     this.gateService = new GateService(this);
     this.qaIndexService = new QaIndexService(this);
     this.mergeService = new MergeService(this);
+    this.gitReconciliationService = new GitReconciliationService(this);
     this.featureDeletionService = new FeatureDeletionService(this);
     this.costTrackingService = new CostTrackingService(this);
     this.performanceAnalyticsService = new PerformanceAnalyticsService(this);
+    this.executionControlService = new ExecutionControlService(this);
     this.gateSelectionService = new GateSelectionService(this);
+    this.questionService = new QuestionService(this);
+    this.intakeService = new IntakeService(this);
     this.repoOperationsService = new RepoOperationsService(this);
     this.sendMessageService = new FeatureSendMessageService({
       readState: (id: string) => this.readState(id),
       getRuntimeSessions: () => this.getRuntimeSessions(),
       getProvider: () => this.provider,
     });
+    this.replayTimelineService = new ReplayTimelineService(this.pathLayout);
     this.toolRouter = new ToolRouter(this.toolHandlers, (toolName) =>
       Promise.resolve(
         fail(ERROR_CODES.INVALID_ARGUMENT, `Unknown tool ${toolName}`, {
@@ -205,6 +230,10 @@ export class AopKernel {
     this.provider = provider;
   }
 
+  getProvider(): WorkerProvider | null {
+    return this.provider;
+  }
+
   getAgentsConfig(): AgentsConfigSnapshot {
     return this.agentsConfig;
   }
@@ -237,6 +266,26 @@ export class AopKernel {
     return this.pathLayout.featuresRoot;
   }
 
+  private isReservedGlobalFeature(featureId: string): boolean {
+    return featureId === 'global';
+  }
+
+  private async ensureReservedGlobalState(featureId: string): Promise<void> {
+    if (!this.isReservedGlobalFeature(featureId)) {
+      return;
+    }
+
+    await this.ensureFeatureLayout(featureId);
+    await this.withFeatureLock(featureId, async () => {
+      if (await pathExists(this.statePath(featureId))) {
+        return;
+      }
+
+      const defaultState = this.makeDefaultState(featureId, featureId, this.repoRoot);
+      await this.writeState(featureId, defaultState, '# Global orchestration state\n');
+    });
+  }
+
   get indexPath() {
     return this.pathLayout.indexPath;
   }
@@ -429,6 +478,10 @@ export class AopKernel {
     return this.pathLayout.qaIndexPath(featureId);
   }
 
+  questionsPath(featureId) {
+    return this.pathLayout.questionsPath(featureId);
+  }
+
   decisionsPath(featureId) {
     return this.pathLayout.decisionsPath(featureId);
   }
@@ -461,15 +514,21 @@ export class AopKernel {
   }
 
   makeDefaultState(featureId, branch, worktreePath) {
-    const configuredExecutionMode =
-      this.agentsConfig.runtime?.execution_mode === 'interactive' ? 'interactive' : 'deterministic';
+    const isReservedGlobal = this.isReservedGlobalFeature(featureId);
     return {
       feature_id: featureId,
       version: 1,
       branch,
       worktree_path: normalizeRepoPathForState(this.repoRoot, worktreePath),
-      status: STATUS.PLANNING,
-      execution_mode: configuredExecutionMode,
+      status: isReservedGlobal ? STATUS.PLANNING : STATUS.INTAKE,
+      intake: {
+        status: isReservedGlobal ? 'verified' : 'in_progress',
+        bootstrap_manifest_version: null,
+        verified_manifest_version: null,
+        open_ambiguity_count: 0,
+        last_verified_at: null,
+        promotion_basis: null,
+      },
       gate_profile: 'default',
       gates: {
         plan: GATE_RESULT.NA,
@@ -487,17 +546,107 @@ export class AopKernel {
       },
       cluster: { ...DEFAULT_CLUSTER },
       role_status: { ...DEFAULT_ROLE_STATUS },
-      checkpoints: [],
+      human_input: {
+        open_question_id: null,
+        open_question_count: 0,
+        awaiting_since: null,
+        requested_by_role: null,
+        prompt_summary: null,
+        resume_status: null,
+      },
+      context_request_count: 0,
+      last_context_request_at: null,
+      last_context_request_role: null,
       last_updated: nowIso(),
     };
   }
 
+  private normalizeStateFrontMatter(frontMatter: AnyRecord): AnyRecord {
+    const humanInput =
+      frontMatter.human_input && typeof frontMatter.human_input === 'object'
+        ? (frontMatter.human_input as Record<string, unknown>)
+        : null;
+    const normalizedHumanInput = {
+      open_question_id:
+        typeof humanInput?.open_question_id === 'string' ? humanInput.open_question_id : null,
+      open_question_count:
+        typeof humanInput?.open_question_count === 'number' &&
+        Number.isFinite(humanInput.open_question_count)
+          ? Math.max(0, Math.floor(humanInput.open_question_count))
+          : 0,
+      awaiting_since:
+        typeof humanInput?.awaiting_since === 'string' ? humanInput.awaiting_since : null,
+      requested_by_role:
+        typeof humanInput?.requested_by_role === 'string' ? humanInput.requested_by_role : null,
+      prompt_summary:
+        typeof humanInput?.prompt_summary === 'string' ? humanInput.prompt_summary : null,
+      resume_status:
+        typeof humanInput?.resume_status === 'string' ? humanInput.resume_status : null,
+    };
+    const hasOpenBlockingQuestion =
+      normalizedHumanInput.open_question_id !== null ||
+      normalizedHumanInput.open_question_count > 0;
+    const normalizedStatus = hasOpenBlockingQuestion ? STATUS.AWAITING_INPUT : frontMatter.status;
+    const normalizedStatusReason =
+      normalizedStatus === STATUS.AWAITING_INPUT && normalizedHumanInput.open_question_id !== null
+        ? `${ERROR_CODES.QUESTION_AWAITING_INPUT}:${normalizedHumanInput.open_question_id}`
+        : frontMatter.status_reason;
+    if (frontMatter.intake && typeof frontMatter.intake === 'object') {
+      return {
+        ...frontMatter,
+        status: normalizedStatus,
+        status_reason: normalizedStatusReason,
+        human_input: normalizedHumanInput,
+        intake:
+          normalizedStatus === STATUS.AWAITING_INPUT &&
+          normalizedHumanInput.resume_status === STATUS.INTAKE
+            ? {
+                ...(frontMatter.intake as Record<string, unknown>),
+                status: 'awaiting_input',
+              }
+            : frontMatter.intake,
+      };
+    }
+    return {
+      ...frontMatter,
+      status: normalizedStatus,
+      status_reason: normalizedStatusReason,
+      human_input: normalizedHumanInput,
+      intake: {
+        status:
+          normalizedStatus === STATUS.INTAKE
+            ? 'in_progress'
+            : normalizedStatus === STATUS.AWAITING_INPUT &&
+                normalizedHumanInput.resume_status === STATUS.INTAKE
+              ? 'awaiting_input'
+              : 'verified',
+        bootstrap_manifest_version: null,
+        verified_manifest_version: null,
+        open_ambiguity_count: 0,
+        last_verified_at: null,
+        promotion_basis: null,
+      },
+    };
+  }
+
   async readState(
     featureId: string,
   ): Promise<{ frontMatter: AnyRecord; body: string; raw: string }> {
     const filePath = this.statePath(featureId);
-    const raw = await fs.readFile(filePath, 'utf8');
+    let raw: string;
+    try {
+      raw = await fs.readFile(filePath, 'utf8');
+    } catch (error) {
+      const typed = error as NodeJS.ErrnoException;
+      if (typed.code !== 'ENOENT' || !this.isReservedGlobalFeature(featureId)) {
+        throw error;
+      }
+
+      await this.ensureReservedGlobalState(featureId);
+      raw = await fs.readFile(filePath, 'utf8');
+    }
     const parsed = parseFrontMatter(raw);
+    parsed.frontMatter = this.normalizeStateFrontMatter(parsed.frontMatter);
     return {
       frontMatter: parsed.frontMatter,
       body: parsed.body,
@@ -506,7 +655,11 @@ export class AopKernel {
   }
 
   async writeState(featureId: string, frontMatter: AnyRecord, body = '') {
-    const validation = await this.schemaRegistry.validate('state.schema.json', frontMatter);
+    const normalizedFrontMatter = this.normalizeStateFrontMatter(frontMatter);
+    const validation = await this.schemaRegistry.validate(
+      'state.schema.json',
+      normalizedFrontMatter,
+    );
     if (!validation.valid) {
       throw {
         normalizedResponse: fail(
@@ -521,7 +674,7 @@ export class AopKernel {
       };
     }
 
-    const markdown = buildFrontMatter(frontMatter, body);
+    const markdown = buildFrontMatter(normalizedFrontMatter, body);
     await atomicWriteFile(this.statePath(featureId), markdown);
   }
 
@@ -642,6 +795,62 @@ export class AopKernel {
     return await this.runLeaseService.updateFeatureSessionAssignment(params);
   }
 
+  async updateReconcilerSession(params: {
+    run_id: string;
+    owner_instance_id: string;
+    reconciler_session_id: string;
+  }): Promise<{ data: { runtime_sessions: RuntimeSessionsSnapshot } }> {
+    return await this.runLeaseService.updateReconcilerSession(params);
+  }
+
+  async updateOrganizerSession(params: {
+    run_id: string;
+    owner_instance_id: string;
+    organizer_session_id: string;
+  }): Promise<{ data: { runtime_sessions: RuntimeSessionsSnapshot } }> {
+    return await this.runLeaseService.updateOrganizerSession(params);
+  }
+
+  async refreshReconcilerSession(): Promise<string | null> {
+    const provider = this.provider;
+    if (!provider) {
+      return null;
+    }
+
+    const runtimeSessions = this.normalizeRuntimeSessions(await this.readRunLease());
+    if (runtimeSessions.run_id === 'none' || runtimeSessions.owner_instance_id === 'none') {
+      return null;
+    }
+
+    const configuredPath = this.agentsConfig.roles?.reconciler?.system_prompt_path;
+    let systemPrompt: string | null = null;
+    if (typeof configuredPath === 'string' && configuredPath.length > 0) {
+      try {
+        systemPrompt = await fs.readFile(path.join(this.repoRoot, configuredPath), 'utf8');
+      } catch {
+        systemPrompt = null;
+      }
+    }
+
+    const previousSessionId = runtimeSessions.reconciler_session_id;
+    const nextSession = await provider.createSession('reconciler', 'global', systemPrompt);
+    await this.updateReconcilerSession({
+      run_id: runtimeSessions.run_id,
+      owner_instance_id: runtimeSessions.owner_instance_id,
+      reconciler_session_id: nextSession.session_id,
+    });
+
+    if (
+      previousSessionId &&
+      previousSessionId !== 'unknown' &&
+      previousSessionId !== nextSession.session_id
+    ) {
+      await provider.closeSession(previousSessionId).catch(() => ({ closed: true }));
+    }
+
+    return nextSession.session_id;
+  }
+
   async pruneFeatureSessionAssignments(params: {
     run_id: string;
     owner_instance_id: string;
@@ -715,17 +924,35 @@ export class AopKernel {
 
   async featureInit(featureId) {
     const initialized = await this.featureLifecycleService.featureInit(featureId);
-    if (featureId) {
+    if (typeof featureId === 'string' && featureId.length > 0) {
+      await this.intakeService.ensureIntakeArtifacts(featureId);
       await this.reconcileStateGateProfile(featureId);
     }
     return initialized;
   }
 
   async featureGetContext(featureId) {
-    await this.reconcileStateGateProfile(featureId);
+    if (typeof featureId === 'string' && featureId.length > 0) {
+      await this.reconcileStateGateProfile(featureId);
+      await this.intakeService.ensureIntakeArtifacts(featureId);
+    }
     return await this.featureLifecycleService.featureGetContext(featureId);
   }
 
+  async featureIntakeContext(featureId: string) {
+    const intake = await this.intakeService.ensureIntakeArtifacts(featureId);
+    return {
+      bootstrap_manifest: intake.bootstrapManifest,
+      verified_manifest: intake.verifiedManifest,
+      review: intake.review,
+      summary: intake.summary,
+    };
+  }
+
+  async featureIntakeSubmit(featureId, intakeSubmission) {
+    return await this.intakeService.intakeSubmit(featureId, intakeSubmission);
+  }
+
   async featureStateGet(featureId) {
     return await this.featureStateService.featureStateGet(featureId);
   }
@@ -786,12 +1013,12 @@ export class AopKernel {
     return await this.patchService.validatePatchPaths(featureId, parsedDiff, plan);
   }
 
-  async repoApplyPatch(featureId, unifiedDiff) {
-    return await this.patchService.repoApplyPatch(featureId, unifiedDiff);
+  async validatePatchDiff(featureId, parsedDiff) {
+    return await this.patchService.validateDiff(featureId, parsedDiff);
   }
 
-  async validatePatchDiff(featureId: string, parsedDiff: unknown): Promise<PatchValidationResult> {
-    return await this.patchService.validateDiff(featureId, parsedDiff);
+  async repoApplyPatch(featureId, unifiedDiff) {
+    return await this.patchService.repoApplyPatch(featureId, unifiedDiff);
   }
 
   async repoStatus(featureId) {
@@ -814,6 +1041,68 @@ export class AopKernel {
     return this.repoOperationsService.repoDiffBundle(featureId);
   }
 
+  async repoReconcileMainline(
+    featureId,
+    baseRef,
+    autoMergeNonConflicting = true,
+    remoteSyncStrategy = null,
+    commitMessage = null,
+  ) {
+    const policy = this.getPolicySnapshot();
+    const normalizedBaseRef =
+      typeof baseRef === 'string' && baseRef.trim().length > 0
+        ? baseRef.trim()
+        : typeof policy?.worktree?.base_branch === 'string' &&
+            policy.worktree.base_branch.trim().length > 0
+          ? policy.worktree.base_branch.trim()
+          : 'main';
+    const normalizedRemoteSyncStrategy =
+      remoteSyncStrategy === 'auto' || remoteSyncStrategy === 'skip' ? remoteSyncStrategy : null;
+
+    const divergenceResult =
+      await this.gitReconciliationService.checkRemoteLocalDivergence(normalizedBaseRef);
+    if (!divergenceResult.ok) {
+      throw { normalizedResponse: divergenceResult };
+    }
+
+    if (divergenceResult.data.diverged) {
+      if (normalizedRemoteSyncStrategy === 'auto') {
+        const syncResult =
+          await this.gitReconciliationService.syncMainlineFromRemote(normalizedBaseRef);
+        if (!syncResult.ok) {
+          throw { normalizedResponse: syncResult };
+        }
+      } else if (normalizedRemoteSyncStrategy !== 'skip') {
+        throw {
+          normalizedResponse: fail(
+            ERROR_CODES.REMOTE_LOCAL_DIVERGENCE,
+            `Local ${normalizedBaseRef} differs from origin/${normalizedBaseRef}`,
+            {
+              base_branch: normalizedBaseRef,
+              local_head: divergenceResult.data.local_head,
+              remote_head: divergenceResult.data.remote_head,
+              retryable: true,
+              requires_human: true,
+            },
+          ),
+        };
+      }
+    }
+
+    if (autoMergeNonConflicting) {
+      return await this.gitReconciliationService.reconcileWithMainline(
+        featureId,
+        normalizedBaseRef,
+        commitMessage,
+      );
+    }
+    return await this.gitReconciliationService.detectDivergence(featureId, normalizedBaseRef);
+  }
+
+  async redrivePreparedReconcilerConflict(featureId) {
+    return await this.gitReconciliationService.redrivePreparedReconcilerConflict(featureId);
+  }
+
   async gatesList(profileName = null) {
     return await this.gateService.gatesList(profileName);
   }
@@ -855,6 +1144,34 @@ export class AopKernel {
     return await this.reportingService.collisionsScan();
   }
 
+  async collisionOverrideAllow(
+    featureId,
+    withFeatureId,
+    reason,
+    resume = false,
+    createdBy = 'cli',
+  ) {
+    return await this.collisionOverrideService.allowOverride({
+      featureId,
+      withFeatureId,
+      reason,
+      resume,
+      createdBy,
+    });
+  }
+
+  async collisionOverrideList(featureId?: string) {
+    return await this.collisionOverrideService.listOverrides(featureId);
+  }
+
+  async collisionOverrideRevoke(overrideId, revokedBy = 'cli') {
+    return await this.collisionOverrideService.revokeOverride(overrideId, revokedBy);
+  }
+
+  async staleCollisionOverridesForFeature(featureId, note, actorId = 'system') {
+    return await this.collisionOverrideService.staleOverridesForFeature(featureId, note, actorId);
+  }
+
   async reportDashboard() {
     return await this.reportingService.reportDashboard();
   }
@@ -863,12 +1180,164 @@ export class AopKernel {
     return await this.reportingService.reportFeatureSummary(featureId);
   }
 
-  async featureReadyToMerge(featureId, commitMessage, mergeStrategy, userApprovalToken) {
+  executionControlPath(instanceId: string): string {
+    return this.pathLayout.executionControlPath(instanceId);
+  }
+
+  async executionRequestSubmit(args: {
+    run_id: string;
+    owner_instance_id: string;
+    request_type: 'add_features';
+    features: Array<{ feature_id: string; spec_path: string }>;
+    operation_id: string;
+    requested_by?: string;
+  }) {
+    return await this.executionControlService.submitExecutionRequest(args);
+  }
+
+  async executionRequestList() {
+    return await this.executionControlService.listExecutionRequests();
+  }
+
+  async drainPendingExecutionRequests(
+    runId: string,
+    ownerInstanceId: string,
+  ): Promise<{
+    data: { items: ExecutionRequestItem[] };
+  }> {
+    return await this.executionControlService.drainPendingExecutionRequests(runId, ownerInstanceId);
+  }
+
+  async markExecutionRequestProcessed(
+    runId: string,
+    ownerInstanceId: string,
+    requestId: string,
+    status: Exclude<ExecutionRequestStatus, 'pending'>,
+    outcome: Exclude<ExecutionRequestOutcome, null>,
+  ): Promise<{ data: { updated: boolean } }> {
+    return await this.executionControlService.markExecutionRequestProcessed(
+      runId,
+      ownerInstanceId,
+      requestId,
+      status,
+      outcome,
+    );
+  }
+
+  async updateExecutionRequestProgress(
+    runId: string,
+    ownerInstanceId: string,
+    requestId: string,
+    patch: {
+      detected_at?: string | null;
+      last_evaluated_at?: string | null;
+      queued?: string[];
+      skipped?: Array<{ feature_id: string; reason: string }>;
+      deferred?: Array<{ feature_id: string; reason: string }>;
+    },
+  ): Promise<{
+    data: {
+      updated: boolean;
+      progress: PendingExecutionRequestProgress | null;
+    };
+  }> {
+    return await this.executionControlService.updateExecutionRequestProgress(
+      runId,
+      ownerInstanceId,
+      requestId,
+      patch,
+    );
+  }
+
+  async featureReadyToMerge(
+    featureId,
+    commitMessage,
+    mergeStrategy,
+    userApprovalToken,
+    remoteSyncStrategy = null,
+  ) {
+    const policy = this.getPolicySnapshot();
+    const baseBranch =
+      typeof policy?.worktree?.base_branch === 'string' &&
+      policy.worktree.base_branch.trim().length > 0
+        ? policy.worktree.base_branch.trim()
+        : 'main';
+
+    const normalizedStrategy =
+      remoteSyncStrategy === 'auto' || remoteSyncStrategy === 'skip' ? remoteSyncStrategy : null;
+
+    const divergenceResult =
+      await this.gitReconciliationService.checkRemoteLocalDivergence(baseBranch);
+    if (!divergenceResult.ok) {
+      throw { normalizedResponse: divergenceResult };
+    }
+
+    if (divergenceResult.data.diverged) {
+      if (normalizedStrategy === 'auto') {
+        const syncResult = await this.gitReconciliationService.syncMainlineFromRemote(baseBranch);
+        if (!syncResult.ok) {
+          throw { normalizedResponse: syncResult };
+        }
+      } else if (normalizedStrategy !== 'skip') {
+        throw {
+          normalizedResponse: fail(
+            ERROR_CODES.REMOTE_LOCAL_DIVERGENCE,
+            `Local ${baseBranch} differs from origin/${baseBranch}`,
+            {
+              base_branch: baseBranch,
+              local_head: divergenceResult.data.local_head,
+              remote_head: divergenceResult.data.remote_head,
+              retryable: true,
+              requires_human: true,
+            },
+          ),
+        };
+      }
+    }
+
+    const reconciliationCfg = policy?.reconciliation;
+    const checkBeforePhases = Array.isArray(reconciliationCfg?.check_before_phases)
+      ? reconciliationCfg.check_before_phases
+      : [];
+    const shouldReconcile =
+      reconciliationCfg?.enabled === true &&
+      (checkBeforePhases.includes('ready_to_merge') || checkBeforePhases.includes('merge'));
+
+    if (shouldReconcile) {
+      const reconcileResult = await this.gitReconciliationService.reconcileWithMainline(
+        featureId,
+        baseBranch,
+        commitMessage,
+      );
+      if (!reconcileResult.ok) {
+        throw { normalizedResponse: reconcileResult };
+      }
+      if (reconcileResult.data.status === 'conflict_detected') {
+        throw {
+          normalizedResponse: fail(
+            ERROR_CODES.RECONCILIATION_FAILED,
+            'Mainline conflict detected before merge',
+            {
+              feature_id: featureId,
+              base_branch: baseBranch,
+              merge_base: reconcileResult.data.merge_base,
+              mainline_head: reconcileResult.data.mainline_head,
+              worktree_head: reconcileResult.data.worktree_head,
+              conflicting_files: reconcileResult.data.conflicting_files,
+              retryable: false,
+              requires_human: true,
+            },
+          ),
+        };
+      }
+    }
+
     return await this.mergeService.featureReadyToMerge(
       featureId,
       commitMessage,
       mergeStrategy,
       userApprovalToken,
+      normalizedStrategy === 'auto',
     );
   }
 
@@ -899,6 +1368,98 @@ export class AopKernel {
     return this.sendMessageService.featureSendMessage(featureId, message);
   }
 
+  async featureQuestionCreate(args: {
+    feature_id: string;
+    role: string;
+    session_id: string;
+    question_type?: string;
+    prompt: string;
+    details?: Record<string, unknown>;
+    expected_answer?: Record<string, unknown>;
+    blocking?: boolean;
+    phase?: string;
+    request_action?: string;
+    resume_status?: string;
+    resume_phase?: string;
+  }) {
+    const response = await this.questionService.questionCreate(args);
+    await this.intakeService.syncReviewFromQuestions(args.feature_id);
+    return response;
+  }
+
+  async featureQuestionList(featureId: string, status: QuestionStatus | 'all' = 'open') {
+    return await this.questionService.questionList(featureId, status);
+  }
+
+  async featureQuestionAnswer(args: {
+    feature_id: string;
+    question_id: string;
+    answer: string | Record<string, unknown>;
+    answered_by: string;
+  }) {
+    const response = await this.questionService.questionAnswer(args);
+    await this.intakeService.syncReviewFromQuestions(args.feature_id);
+    await this.maybeQueueAnsweredFeatureForResume(args.feature_id, args.question_id, response.data);
+    return response;
+  }
+
+  async featureQuestionContext(featureId: string) {
+    return await this.questionService.questionContext(featureId);
+  }
+
+  private async maybeQueueAnsweredFeatureForResume(
+    featureId: string,
+    questionId: string,
+    result: {
+      feature_status: string;
+      resume_status: string | null;
+      resumed: boolean;
+    },
+  ): Promise<void> {
+    if (!result.resumed) {
+      return;
+    }
+
+    const runtimeSessions = await this.getRuntimeSessions();
+    if (
+      runtimeSessions.run_id === 'none' ||
+      runtimeSessions.owner_instance_id === 'none' ||
+      !this.isRunLeaseFresh(runtimeSessions)
+    ) {
+      return;
+    }
+
+    const assignedFeatureSessions = runtimeSessions.feature_sessions ?? {};
+    if (assignedFeatureSessions[featureId]) {
+      return;
+    }
+
+    const specPath = normalizeRepoPathForState(this.getRepoRoot(), this.specPath(featureId));
+    const operationId = `question_answer_resume__${featureId}__${questionId}`;
+    try {
+      await this.executionRequestSubmit({
+        run_id: runtimeSessions.run_id,
+        owner_instance_id: runtimeSessions.owner_instance_id,
+        request_type: 'add_features',
+        features: [{ feature_id: featureId, spec_path: specPath }],
+        operation_id: operationId,
+        requested_by: 'question_answer:auto_resume',
+      });
+    } catch (error) {
+      const normalizedCode =
+        (error as { normalizedResponse?: { error?: { code?: string } } })?.normalizedResponse?.error
+          ?.code ?? null;
+      if (
+        normalizedCode === ERROR_CODES.RUN_NOT_ACTIVE ||
+        normalizedCode === ERROR_CODES.EXECUTION_REQUEST_TARGET_MISMATCH ||
+        normalizedCode === ERROR_CODES.DUPLICATE_EXECUTION_REQUEST
+      ) {
+        return;
+      }
+      throw error;
+    }
+  }
+
   async costRecord(featureId: string, tokensDelta: number, costUsdDelta: number) {
     const updated = await this.costTrackingService.recordCost(featureId, tokensDelta, costUsdDelta);
     return { ok: true as const, data: updated };
@@ -948,4 +1509,31 @@ export class AopKernel {
     const snapshot = await this.performanceAnalyticsService.getAnalytics();
     return { ok: true as const, data: snapshot };
   }
+
+  async replayTimelineGet(
+    runId: string | null,
+    fromSequence: number | null,
+    limit: number | null,
+    featureId: string | null,
+    toolName: string | null,
+  ) {
+    if (!runId) {
+      throw {
+        normalizedResponse: fail(ERROR_CODES.INVALID_ARGUMENT, 'run_id is required', {
+          retryable: false,
+          requires_human: false,
+        }),
+      };
+    }
+    const result = await this.replayTimelineService.timelineGet(runId, {
+      from_sequence: fromSequence ?? undefined,
+      limit: limit ?? undefined,
+      feature_id: featureId ?? undefined,
+      tool_name: toolName ?? undefined,
+    });
+    if (!result.ok) {
+      throw { normalizedResponse: result };
+    }
+    return { data: result.data };
+  }
 }