agentic-orchestrator 0.1.28 → 0.2.0

package/dist/apps/control-plane/core/kernel.d.ts

@@ -3,13 +3,15 @@ import { type ToolResponse } from './response.js';
 import type { RuntimeSessionsSnapshot } from './runtime-sessions.js';
 import { ToolHandlerRegistry, ToolRouter, type ToolHandlerContext } from '../application/tools/tool-router.js';
 import { type AcquireRunLeaseInput } from '../application/services/run-lease-service.js';
-import { type PatchValidationResult } from '../application/services/patch-service.js';
+import { GitReconciliationService } from '../application/services/git-reconciliation-service.js';
 import { CollisionQueueService } from '../application/services/collision-queue-service.js';
 import { type FeatureDeleteResult } from '../application/services/feature-deletion-service.js';
 import { type FeatureOutcome } from '../application/services/performance-analytics-service.js';
 import type { WorkerProvider } from '../providers/providers.js';
 import type { AnyRecord, KernelContext, KernelConfigOverrides, AgentsConfigSnapshot, PolicyConfigSnapshot } from './kernel-types.js';
 export type { AgentsConfigSnapshot } from './kernel-types.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.
  *
@@ -59,6 +61,7 @@ export declare class AopKernel {
     private readonly runLeaseService;
     private readonly lockService;
     readonly collisionQueueService: CollisionQueueService;
+    private readonly collisionOverrideService;
     private readonly reportingService;
     private readonly featureStateService;
     private readonly featureLifecycleService;
@@ -67,12 +70,17 @@ export declare class AopKernel {
     private readonly gateService;
     private readonly qaIndexService;
     private readonly mergeService;
+    readonly gitReconciliationService: GitReconciliationService;
     private readonly featureDeletionService;
     private readonly costTrackingService;
     private readonly performanceAnalyticsService;
+    private readonly executionControlService;
     private readonly gateSelectionService;
+    private readonly questionService;
+    private readonly intakeService;
     private readonly repoOperationsService;
     private readonly sendMessageService;
+    private readonly replayTimelineService;
     private readonly pathLayout;
     readonly instanceId: string;
     private provider;
@@ -87,6 +95,7 @@ export declare class AopKernel {
     constructor(repoRoot: string, instanceId?: string, configOverrides?: KernelConfigOverrides);
     getRepoRoot(): string;
     setProvider(provider: WorkerProvider): void;
+    getProvider(): WorkerProvider | null;
     getAgentsConfig(): AgentsConfigSnapshot;
     getRbacPolicy(): Record<string, string[]>;
     getAdaptersConfig(): Record<string, unknown>;
@@ -95,6 +104,8 @@ export declare class AopKernel {
     getFeaturesDir(): string;
     get orchestratorDir(): string;
     get featuresDir(): string;
+    private isReservedGlobalFeature;
+    private ensureReservedGlobalState;
     get indexPath(): string;
     get indexLockPath(): string;
     runLeaseTtlSeconds(): number;
@@ -115,6 +126,7 @@ export declare class AopKernel {
     featureCostPath(featureId: string): string;
     analyticsPath(): string;
     qaIndexPath(featureId: any): string;
+    questionsPath(featureId: any): string;
     decisionsPath(featureId: any): string;
     logsPath(featureId: any): string;
     evidencePath(featureId: any): string;
@@ -126,8 +138,15 @@ export declare class AopKernel {
         version: number;
         branch: any;
         worktree_path: string;
-        status: "planning";
-        execution_mode: string;
+        status: "intake" | "planning";
+        intake: {
+            status: string;
+            bootstrap_manifest_version: any;
+            verified_manifest_version: any;
+            open_ambiguity_count: number;
+            last_verified_at: any;
+            promotion_basis: any;
+        };
         gate_profile: string;
         gates: {
             plan: "na";
@@ -148,15 +167,27 @@ export declare class AopKernel {
             planner_session_id: string;
             builder_session_id: string;
             qa_session_id: string;
+            reconciler_session_id: string;
         };
         role_status: {
             planner: "ready";
             builder: "ready";
             qa: "ready";
         };
-        checkpoints: any[];
+        human_input: {
+            open_question_id: any;
+            open_question_count: number;
+            awaiting_since: any;
+            requested_by_role: any;
+            prompt_summary: any;
+            resume_status: any;
+        };
+        context_request_count: number;
+        last_context_request_at: any;
+        last_context_request_role: any;
         last_updated: string;
     };
+    private normalizeStateFrontMatter;
     readState(featureId: string): Promise<{
         frontMatter: AnyRecord;
         body: string;
@@ -213,6 +244,25 @@ export declare class AopKernel {
             updated: boolean;
         };
     }>;
+    updateReconcilerSession(params: {
+        run_id: string;
+        owner_instance_id: string;
+        reconciler_session_id: string;
+    }): Promise<{
+        data: {
+            runtime_sessions: RuntimeSessionsSnapshot;
+        };
+    }>;
+    updateOrganizerSession(params: {
+        run_id: string;
+        owner_instance_id: string;
+        organizer_session_id: string;
+    }): Promise<{
+        data: {
+            runtime_sessions: RuntimeSessionsSnapshot;
+        };
+    }>;
+    refreshReconcilerSession(): Promise<string | null>;
     pruneFeatureSessionAssignments(params: {
         run_id: string;
         owner_instance_id: string;
@@ -253,6 +303,32 @@ export declare class AopKernel {
             plan: unknown;
             qa_test_index: unknown;
             latest_evidence: unknown;
+            gate_evidence_by_mode: Record<string, unknown>;
+            decision_log: string;
+            human_input: {
+                open_questions: unknown[];
+                latest_answer: unknown | null;
+            };
+            intake: {
+                bootstrap_manifest: unknown | null;
+                verified_manifest: unknown | null;
+                review: unknown | null;
+                summary: unknown;
+            };
+        };
+    }>;
+    featureIntakeContext(featureId: string): Promise<{
+        bootstrap_manifest: import("./intake-artifacts.js").BootstrapManifest;
+        verified_manifest: import("./intake-artifacts.js").VerifiedManifest;
+        review: import("./intake-artifacts.js").IntakeReview;
+        summary: import("./intake-artifacts.js").IntakeSummary;
+    }>;
+    featureIntakeSubmit(featureId: any, intakeSubmission: any): Promise<{
+        data: {
+            feature_id: string;
+            accepted: boolean;
+            feature_status: string;
+            verified_manifest_version: number;
         };
     }>;
     featureStateGet(featureId: any): Promise<{
@@ -317,6 +393,7 @@ export declare class AopKernel {
         [x: string]: any;
     }>;
     validatePatchPaths(featureId: any, parsedDiff: any, plan: any): Promise<string[]>;
+    validatePatchDiff(featureId: any, parsedDiff: any): Promise<import("../application/services/patch-service.js").PatchValidationResult>;
     repoApplyPatch(featureId: any, unifiedDiff: any): Promise<{
         data: {
             feature_id: string;
@@ -325,7 +402,6 @@ export declare class AopKernel {
             qa_index_version: number;
         };
     }>;
-    validatePatchDiff(featureId: string, parsedDiff: unknown): Promise<PatchValidationResult>;
     repoStatus(featureId: any): Promise<{
         data: {
             feature_id: string;
@@ -372,6 +448,8 @@ export declare class AopKernel {
             last_gate_summary: unknown;
         };
     }>;
+    repoReconcileMainline(featureId: any, baseRef: any, autoMergeNonConflicting?: boolean, remoteSyncStrategy?: any, commitMessage?: any): Promise<ToolResponse<import("../application/services/git-reconciliation-service.js").ReconciliationResult>>;
+    redrivePreparedReconcilerConflict(featureId: any): Promise<boolean>;
     gatesList(profileName?: any): Promise<{
         data: {
             [x: string]: any;
@@ -444,14 +522,51 @@ export declare class AopKernel {
     collisionsScan(): Promise<{
         data: {
             collisions: any[];
-        };
-    }>;
+            stale_overrides: {
+                override_id: string;
+                feature_ids: [string, string];
+                status: "stale" | "active" | "applied" | "revoked";
+                rationale: string;
+                approved_paths: string[];
+                last_seen_at: string;
+            }[];
+            revoked_overrides: {
+                override_id: string;
+                feature_ids: [string, string];
+                status: "stale" | "active" | "applied" | "revoked";
+                rationale: string;
+                approved_paths: string[];
+                last_seen_at: string;
+            }[];
+        };
+    }>;
+    collisionOverrideAllow(featureId: any, withFeatureId: any, reason: any, resume?: boolean, createdBy?: string): Promise<{
+        override_id: string;
+        feature_ids: [string, string];
+        collision_fingerprint: string;
+        approved_paths: string[];
+        resumed: boolean;
+    }>;
+    collisionOverrideList(featureId?: string): Promise<(import("../application/services/collision-override-service.js").CollisionOverride & {
+        latest_seen_at: string | null;
+        matches_live_collision: boolean;
+        applied_successfully: boolean;
+    })[]>;
+    collisionOverrideRevoke(overrideId: any, revokedBy?: string): Promise<import("../application/services/collision-override-service.js").CollisionOverride>;
+    staleCollisionOverridesForFeature(featureId: any, note: any, actorId?: string): Promise<void>;
     reportDashboard(): Promise<{
         data: {
             index: {
                 [x: string]: any;
             };
             features: any[];
+            collision_summary: {
+                active_unapproved: number;
+                active_approved: number;
+                stale_overrides: number;
+                revoked_overrides: number;
+            };
+            execution_requests: import("./execution-control.js").ExecutionControlSnapshot;
         };
     }>;
     reportFeatureSummary(featureId: any): Promise<{
@@ -464,13 +579,94 @@ export declare class AopKernel {
             touched_files: any;
             last_gate_summary: any;
             qa_summary: any;
+            active_collision_overrides: {
+                override_id: string;
+                status: "stale" | "active" | "applied" | "revoked";
+                counterpart_feature_id: string;
+                rationale: string;
+                approved_paths: string[];
+                approved_collision_fingerprint: string;
+                last_seen_at: string;
+                applied_at: string;
+            }[];
+            recent_collision_records: {
+                collision_id: string;
+                feature_id: string;
+                with_feature_ids: string[];
+                detected_at: string;
+                collision_fingerprint: string;
+                collisions: import("./collisions.js").PlanCollisionsShape;
+                resolution: string;
+                resolution_details?: {
+                    override_id?: string;
+                    resolved_at?: string;
+                    note?: string;
+                };
+            }[];
+            latest_collision_status: {
+                collision_id: string;
+                resolution: string;
+                resolved_at: string;
+                override_id: string;
+            };
+        };
+    }>;
+    executionControlPath(instanceId: string): string;
+    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;
+    }): Promise<{
+        data: {
+            run_id: string;
+            request_id: string;
+            request_status: "pending";
+            requested_features: import("./execution-control.js").ExecutionRequestFeature[];
+        };
+    }>;
+    executionRequestList(): Promise<{
+        data: import("./execution-control.js").ExecutionControlSnapshot;
+    }>;
+    drainPendingExecutionRequests(runId: string, ownerInstanceId: string): Promise<{
+        data: {
+            items: ExecutionRequestItem[];
+        };
+    }>;
+    markExecutionRequestProcessed(runId: string, ownerInstanceId: string, requestId: string, status: Exclude<ExecutionRequestStatus, 'pending'>, outcome: Exclude<ExecutionRequestOutcome, null>): Promise<{
+        data: {
+            updated: boolean;
+        };
+    }>;
+    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;
         };
     }>;
-    featureReadyToMerge(featureId: any, commitMessage: any, mergeStrategy: any, userApprovalToken: any): Promise<{
+    featureReadyToMerge(featureId: any, commitMessage: any, mergeStrategy: any, userApprovalToken: any, remoteSyncStrategy?: any): Promise<{
         data: {
             feature_id: string;
             merge_sha: string;
             merge_strategy: string;
+            merge_target: string;
             status: string;
             retained_for_cleanup?: boolean;
             cleanup_grace_period_seconds?: number;
@@ -486,6 +682,52 @@ export declare class AopKernel {
         };
     }>;
     featureSendMessage(featureId: string | null, message: string | null): Promise<unknown>;
+    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;
+    }): Promise<{
+        data: {
+            question_id: string;
+            status: QuestionStatus;
+            feature_status: string;
+            resume_status: string | null;
+        };
+    }>;
+    featureQuestionList(featureId: string, status?: QuestionStatus | 'all'): Promise<{
+        data: {
+            items: import("./questions.js").QuestionRecord[];
+        };
+    }>;
+    featureQuestionAnswer(args: {
+        feature_id: string;
+        question_id: string;
+        answer: string | Record<string, unknown>;
+        answered_by: string;
+    }): Promise<{
+        data: {
+            feature_id: string;
+            question_id: string;
+            question_status: QuestionStatus;
+            feature_status: string;
+            resume_status: string | null;
+            resumed: boolean;
+        };
+    }>;
+    featureQuestionContext(featureId: string): Promise<{
+        open_questions: import("./questions.js").QuestionRecord[];
+        latest_answer: import("./questions.js").QuestionRecord | null;
+    }>;
+    private maybeQueueAnsweredFeatureForResume;
     costRecord(featureId: string, tokensDelta: number, costUsdDelta: number): Promise<{
         ok: true;
         data: import("../application/services/cost-tracking-service.js").FeatureCost;
@@ -508,5 +750,11 @@ export declare class AopKernel {
             aggregates: import("../application/services/performance-analytics-service.js").ProviderModelStats[];
             generated_at: string;
         };
+    } | {
+        ok: true;
+        data: import("../application/services/performance-analytics-service.js").AnalyticsSnapshot;
+    }>;
+    replayTimelineGet(runId: string | null, fromSequence: number | null, limit: number | null, featureId: string | null, toolName: string | null): Promise<{
+        data: Record<string, unknown>;
     }>;
 }