agentic-orchestrator 0.1.28 → 0.2.1

package/dist/apps/control-plane/core/kernel.js

@@ -18,11 +18,16 @@ 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, } from '../application/services/feature-deletion-service.js';
 import { CostTrackingService } from '../application/services/cost-tracking-service.js';
 import { PerformanceAnalyticsService, } 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 { readStringField } from './utils/field-readers.js';
 import { emptyRuntimeSessions as utilEmptyRuntimeSessions, normalizeRuntimeSessions as utilNormalizeRuntimeSessions, normalizeIndexShape as utilNormalizeIndexShape, isRunLeaseFresh as utilIsRunLeaseFresh, } from './utils/index-normalizer.js';
 import { normalizeRepoPathForState } from './utils/path-normalizers.js';
@@ -30,6 +35,7 @@ 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';
 /**
  * Deterministic orchestration kernel for multi-agent feature development.
  *
@@ -79,6 +85,7 @@ export class AopKernel {
     runLeaseService;
     lockService;
     collisionQueueService;
+    collisionOverrideService;
     reportingService;
     featureStateService;
     featureLifecycleService;
@@ -87,12 +94,17 @@ export class AopKernel {
     gateService;
     qaIndexService;
     mergeService;
+    gitReconciliationService;
     featureDeletionService;
     costTrackingService;
     performanceAnalyticsService;
+    executionControlService;
     gateSelectionService;
+    questionService;
+    intakeService;
     repoOperationsService;
     sendMessageService;
+    replayTimelineService;
     pathLayout;
     instanceId;
     provider = null;
@@ -120,6 +132,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);
@@ -129,16 +142,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) => 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}`, {
             retryable: false,
             requires_human: true,
@@ -150,6 +168,9 @@ export class AopKernel {
     setProvider(provider) {
         this.provider = provider;
     }
+    getProvider() {
+        return this.provider;
+    }
     getAgentsConfig() {
         return this.agentsConfig;
     }
@@ -174,6 +195,22 @@ export class AopKernel {
     get featuresDir() {
         return this.pathLayout.featuresRoot;
     }
+    isReservedGlobalFeature(featureId) {
+        return featureId === 'global';
+    }
+    async ensureReservedGlobalState(featureId) {
+        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;
     }
@@ -311,6 +348,9 @@ export class AopKernel {
     qaIndexPath(featureId) {
         return this.pathLayout.qaIndexPath(featureId);
     }
+    questionsPath(featureId) {
+        return this.pathLayout.questionsPath(featureId);
+    }
     decisionsPath(featureId) {
         return this.pathLayout.decisionsPath(featureId);
     }
@@ -337,14 +377,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,
@@ -362,14 +409,92 @@ 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(),
         };
     }
+    normalizeStateFrontMatter(frontMatter) {
+        const humanInput = frontMatter.human_input && typeof frontMatter.human_input === 'object'
+            ? frontMatter.human_input
+            : 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,
+                        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) {
         const filePath = this.statePath(featureId);
-        const raw = await fs.readFile(filePath, 'utf8');
+        let raw;
+        try {
+            raw = await fs.readFile(filePath, 'utf8');
+        }
+        catch (error) {
+            const typed = error;
+            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,
@@ -377,7 +502,8 @@ export class AopKernel {
         };
     }
     async writeState(featureId, frontMatter, 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(ERROR_CODES.STATE_VALIDATION_FAILED, 'state.md front matter failed schema validation', {
@@ -387,7 +513,7 @@ export class AopKernel {
                 }),
             };
         }
-        const markdown = buildFrontMatter(frontMatter, body);
+        const markdown = buildFrontMatter(normalizedFrontMatter, body);
         await atomicWriteFile(this.statePath(featureId), markdown);
     }
     async withFeatureLock(featureId, operation) {
@@ -462,6 +588,45 @@ export class AopKernel {
     async updateFeatureSessionAssignment(params) {
         return await this.runLeaseService.updateFeatureSessionAssignment(params);
     }
+    async updateReconcilerSession(params) {
+        return await this.runLeaseService.updateReconcilerSession(params);
+    }
+    async updateOrganizerSession(params) {
+        return await this.runLeaseService.updateOrganizerSession(params);
+    }
+    async refreshReconcilerSession() {
+        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 = 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) {
         return await this.runLeaseService.pruneFeatureSessionAssignments(params);
     }
@@ -508,15 +673,31 @@ 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) {
+        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);
     }
@@ -562,12 +743,12 @@ export class AopKernel {
     async validatePatchPaths(featureId, parsedDiff, plan) {
         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 repoApplyPatch(featureId, unifiedDiff) {
+        return await this.patchService.repoApplyPatch(featureId, unifiedDiff);
+    }
     async repoStatus(featureId) {
         return this.repoOperationsService.repoStatus(featureId);
     }
@@ -583,6 +764,46 @@ export class AopKernel {
     async repoDiffBundle(featureId) {
         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);
     }
@@ -610,14 +831,105 @@ export class AopKernel {
     async collisionsScan() {
         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) {
+        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();
     }
     async reportFeatureSummary(featureId) {
         return await this.reportingService.reportFeatureSummary(featureId);
     }
-    async featureReadyToMerge(featureId, commitMessage, mergeStrategy, userApprovalToken) {
-        return await this.mergeService.featureReadyToMerge(featureId, commitMessage, mergeStrategy, userApprovalToken);
+    executionControlPath(instanceId) {
+        return this.pathLayout.executionControlPath(instanceId);
+    }
+    async executionRequestSubmit(args) {
+        return await this.executionControlService.submitExecutionRequest(args);
+    }
+    async executionRequestList() {
+        return await this.executionControlService.listExecutionRequests();
+    }
+    async drainPendingExecutionRequests(runId, ownerInstanceId) {
+        return await this.executionControlService.drainPendingExecutionRequests(runId, ownerInstanceId);
+    }
+    async markExecutionRequestProcessed(runId, ownerInstanceId, requestId, status, outcome) {
+        return await this.executionControlService.markExecutionRequestProcessed(runId, ownerInstanceId, requestId, status, outcome);
+    }
+    async updateExecutionRequestProgress(runId, ownerInstanceId, requestId, patch) {
+        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');
     }
     async featureDelete(featureId, dryRun, confirm, removeWorktree, removeBranch) {
         return await this.featureDeletionService.featureDelete(featureId, {
@@ -636,6 +948,60 @@ export class AopKernel {
     async featureSendMessage(featureId, message) {
         return this.sendMessageService.featureSendMessage(featureId, message);
     }
+    async featureQuestionCreate(args) {
+        const response = await this.questionService.questionCreate(args);
+        await this.intakeService.syncReviewFromQuestions(args.feature_id);
+        return response;
+    }
+    async featureQuestionList(featureId, status = 'open') {
+        return await this.questionService.questionList(featureId, status);
+    }
+    async featureQuestionAnswer(args) {
+        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) {
+        return await this.questionService.questionContext(featureId);
+    }
+    async maybeQueueAnsweredFeatureForResume(featureId, questionId, result) {
+        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?.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, tokensDelta, costUsdDelta) {
         const updated = await this.costTrackingService.recordCost(featureId, tokensDelta, costUsdDelta);
         return { ok: true, data: updated };
@@ -678,5 +1044,25 @@ export class AopKernel {
         const snapshot = await this.performanceAnalyticsService.getAnalytics();
         return { ok: true, data: snapshot };
     }
+    async replayTimelineGet(runId, fromSequence, limit, featureId, toolName) {
+        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 };
+    }
 }
 //# sourceMappingURL=kernel.js.map