npm - @shepai/cli - Versions diffs - 1.169.1 → 1.170.0-pr513.cff27cb - Mend

@shepai/cli 1.169.1 → 1.170.0-pr513.cff27cb

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (546) hide show

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/exploration-agent-graph.d.ts ADDED Viewed

@@ -0,0 +1,362 @@
+/**
+ * Exploration Agent Graph Factory
+ *
+ * Creates a LangGraph StateGraph for exploration/prototyping mode with
+ * the topology:
+ *   START → prototype-generate → (interrupt for feedback)
+ *     → apply-feedback → prototype-generate (loop)
+ *     → END (on promote or discard)
+ *
+ * The graph uses the same FeatureAgentAnnotation state shape as the
+ * full and fast graphs, enabling checkpointing, resume, and identical
+ * worker lifecycle handling.
+ *
+ * Unlike the full SDLC graph which uses executeNode() with approval gates,
+ * the exploration graph uses custom node functions with shared utilities
+ * (retryExecute, createNodeLogger). The feedback loop is driven by
+ * LangGraph interrupt/resume — the same mechanism used for approval gates.
+ */
+import { type BaseCheckpointSaver } from '@langchain/langgraph';
+import type { IAgentExecutor } from '../../../../application/ports/output/agents/agent-executor.interface.js';
+import { type FeatureAgentState } from './state.js';
+export { FeatureAgentAnnotation, type FeatureAgentState } from './state.js';
+/**
+ * Dependencies needed to build the exploration agent graph.
+ * Intentionally minimal — exploration mode does not use merge nodes.
+ */
+export interface ExplorationAgentGraphDeps {
+    executor: IAgentExecutor;
+}
+/**
+ * Routing function that determines the next node after prototype-generate
+ * resumes from interrupt.
+ *
+ * The resume payload (set via Command({update})) controls the flow:
+ * - _approvalAction === 'rejected' → apply-feedback (iterate with feedback)
+ * - _approvalAction === 'approved' or any other → END (promote or discard)
+ *
+ * The 'rejected' action maps to the iterate flow because the existing
+ * worker resume logic already sets _approvalAction='rejected' and
+ * _rejectionFeedback=<text> for rejection payloads. For exploration,
+ * "rejected" means "iterate with feedback" rather than "rejected for merge".
+ */
+export declare function routeAfterPrototypeGenerate(state: FeatureAgentState): string;
+/**
+ * Factory function that creates and compiles the exploration-mode agent graph.
+ *
+ * The graph defines a feedback loop:
+ *   START → prototype-generate → (interrupt) → route:
+ *     - iterate: → apply-feedback → prototype-generate (loop)
+ *     - promote/discard: → END
+ *
+ * @param depsOrExecutor - Graph dependencies or a legacy executor
+ * @param checkpointer - Optional checkpoint saver for state persistence
+ * @returns A compiled LangGraph ready to be invoked
+ */
+export declare function createExplorationAgentGraph(depsOrExecutor: ExplorationAgentGraphDeps | IAgentExecutor, checkpointer?: BaseCheckpointSaver): import("@langchain/langgraph").CompiledStateGraph<{
+    featureId: string;
+    repositoryPath: string;
+    specDir: string;
+    worktreePath: string;
+    currentNode: string;
+    error: string | null;
+    approvalGates: import("../../../../domain/index.js").ApprovalGates | undefined;
+    model: string | undefined;
+    messages: string[];
+    validationRetries: number;
+    lastValidationTarget: string;
+    lastValidationErrors: string[];
+    _approvalAction: string | null;
+    _rejectionFeedback: string | null;
+    _needsReexecution: boolean;
+    prUrl: string | null;
+    prNumber: number | null;
+    commitHash: string | null;
+    ciStatus: string | null;
+    push: boolean;
+    openPr: boolean;
+    forkAndPr: boolean;
+    commitSpecs: boolean;
+    ciWatchEnabled: boolean;
+    enableEvidence: boolean;
+    commitEvidence: boolean;
+    evidence: import("../../../../domain/index.js").Evidence[];
+    evidenceRetries: number;
+    resumeReason: string | undefined;
+    ciFixAttempts: number;
+    ciFixHistory: import("../../../../domain/index.js").CiFixRecord[];
+    ciFixStatus: "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted";
+    iterationCount: number;
+    maxIterations: number;
+    feedbackHistory: string[];
+    explorationStatus: "generating" | "waiting-feedback" | "applying-feedback" | "promoting" | "discarding" | undefined;
+}, {
+    featureId?: string | undefined;
+    repositoryPath?: string | undefined;
+    specDir?: string | undefined;
+    worktreePath?: string | undefined;
+    currentNode?: string | undefined;
+    error?: string | null | undefined;
+    approvalGates?: import("../../../../domain/index.js").ApprovalGates | undefined;
+    model?: string | undefined;
+    messages?: string[] | undefined;
+    validationRetries?: number | undefined;
+    lastValidationTarget?: string | undefined;
+    lastValidationErrors?: string[] | undefined;
+    _approvalAction?: string | null | undefined;
+    _rejectionFeedback?: string | null | undefined;
+    _needsReexecution?: boolean | undefined;
+    prUrl?: string | null | undefined;
+    prNumber?: number | null | undefined;
+    commitHash?: string | null | undefined;
+    ciStatus?: string | null | undefined;
+    push?: boolean | undefined;
+    openPr?: boolean | undefined;
+    forkAndPr?: boolean | undefined;
+    commitSpecs?: boolean | undefined;
+    ciWatchEnabled?: boolean | undefined;
+    enableEvidence?: boolean | undefined;
+    commitEvidence?: boolean | undefined;
+    evidence?: import("../../../../domain/index.js").Evidence[] | undefined;
+    evidenceRetries?: number | undefined;
+    resumeReason?: string | undefined;
+    ciFixAttempts?: number | undefined;
+    ciFixHistory?: import("../../../../domain/index.js").CiFixRecord[] | undefined;
+    ciFixStatus?: "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted" | undefined;
+    iterationCount?: number | undefined;
+    maxIterations?: number | undefined;
+    feedbackHistory?: string[] | undefined;
+    explorationStatus?: "generating" | "waiting-feedback" | "applying-feedback" | "promoting" | "discarding" | undefined;
+}, "__start__" | "prototype-generate" | "apply-feedback", {
+    featureId: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    repositoryPath: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    specDir: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    worktreePath: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    currentNode: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+    approvalGates: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").ApprovalGates | undefined, import("../../../../domain/index.js").ApprovalGates | undefined>;
+    model: import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+    messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+    lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+    lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    _approvalAction: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+    _rejectionFeedback: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+    _needsReexecution: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+    prUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+    prNumber: import("@langchain/langgraph").BinaryOperatorAggregate<number | null, number | null>;
+    commitHash: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+    ciStatus: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+    push: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+    openPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+    forkAndPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+    commitSpecs: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+    ciWatchEnabled: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+    enableEvidence: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+    commitEvidence: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+    evidence: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").Evidence[], import("../../../../domain/index.js").Evidence[]>;
+    evidenceRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+    resumeReason: import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+    ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+    ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
+    ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
+    iterationCount: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+    maxIterations: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+    feedbackHistory: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    explorationStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"generating" | "waiting-feedback" | "applying-feedback" | "promoting" | "discarding" | undefined, "generating" | "waiting-feedback" | "applying-feedback" | "promoting" | "discarding" | undefined>;
+}, {
+    featureId: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    repositoryPath: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    specDir: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    worktreePath: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    currentNode: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+    approvalGates: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").ApprovalGates | undefined, import("../../../../domain/index.js").ApprovalGates | undefined>;
+    model: import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+    messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+    lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+    lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    _approvalAction: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+    _rejectionFeedback: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+    _needsReexecution: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+    prUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+    prNumber: import("@langchain/langgraph").BinaryOperatorAggregate<number | null, number | null>;
+    commitHash: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+    ciStatus: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+    push: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+    openPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+    forkAndPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+    commitSpecs: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+    ciWatchEnabled: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+    enableEvidence: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+    commitEvidence: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+    evidence: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").Evidence[], import("../../../../domain/index.js").Evidence[]>;
+    evidenceRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+    resumeReason: import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+    ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+    ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
+    ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
+    iterationCount: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+    maxIterations: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+    feedbackHistory: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    explorationStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"generating" | "waiting-feedback" | "applying-feedback" | "promoting" | "discarding" | undefined, "generating" | "waiting-feedback" | "applying-feedback" | "promoting" | "discarding" | undefined>;
+}, import("@langchain/langgraph").StateDefinition, {
+    "prototype-generate": Partial<import("@langchain/langgraph").StateType<{
+        featureId: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        repositoryPath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        specDir: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        worktreePath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        currentNode: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        approvalGates: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").ApprovalGates | undefined, import("../../../../domain/index.js").ApprovalGates | undefined>;
+        model: import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        _approvalAction: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _rejectionFeedback: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _needsReexecution: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        prUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        prNumber: import("@langchain/langgraph").BinaryOperatorAggregate<number | null, number | null>;
+        commitHash: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        ciStatus: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        push: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        openPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        forkAndPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        commitSpecs: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        ciWatchEnabled: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        enableEvidence: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        commitEvidence: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        evidence: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").Evidence[], import("../../../../domain/index.js").Evidence[]>;
+        evidenceRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        resumeReason: import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
+        ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
+        iterationCount: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        maxIterations: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        feedbackHistory: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        explorationStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"generating" | "waiting-feedback" | "applying-feedback" | "promoting" | "discarding" | undefined, "generating" | "waiting-feedback" | "applying-feedback" | "promoting" | "discarding" | undefined>;
+    }>>;
+    "apply-feedback": Partial<import("@langchain/langgraph").StateType<{
+        featureId: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        repositoryPath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        specDir: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        worktreePath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        currentNode: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        approvalGates: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").ApprovalGates | undefined, import("../../../../domain/index.js").ApprovalGates | undefined>;
+        model: import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        _approvalAction: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _rejectionFeedback: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        _needsReexecution: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        prUrl: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        prNumber: import("@langchain/langgraph").BinaryOperatorAggregate<number | null, number | null>;
+        commitHash: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        ciStatus: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
+        push: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        openPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        forkAndPr: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        commitSpecs: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        ciWatchEnabled: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        enableEvidence: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        commitEvidence: import("@langchain/langgraph").BinaryOperatorAggregate<boolean, boolean>;
+        evidence: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").Evidence[], import("../../../../domain/index.js").Evidence[]>;
+        evidenceRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        resumeReason: import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
+        ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
+        iterationCount: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        maxIterations: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        feedbackHistory: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        explorationStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"generating" | "waiting-feedback" | "applying-feedback" | "promoting" | "discarding" | undefined, "generating" | "waiting-feedback" | "applying-feedback" | "promoting" | "discarding" | undefined>;
+    }>>;
+}, unknown, unknown>;
+//# sourceMappingURL=exploration-agent-graph.d.ts.map

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/exploration-agent-graph.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"exploration-agent-graph.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/exploration-agent-graph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAqB,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AACnF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AACpG,OAAO,EAA0B,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAK5E,OAAO,EAAE,sBAAsB,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE5E;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,CAO5E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CACzC,cAAc,EAAE,yBAAyB,GAAG,cAAc,EAC1D,YAAY,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAqBnC"}

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/exploration-agent-graph.js ADDED Viewed

@@ -0,0 +1,72 @@
+/**
+ * Exploration Agent Graph Factory
+ *
+ * Creates a LangGraph StateGraph for exploration/prototyping mode with
+ * the topology:
+ *   START → prototype-generate → (interrupt for feedback)
+ *     → apply-feedback → prototype-generate (loop)
+ *     → END (on promote or discard)
+ *
+ * The graph uses the same FeatureAgentAnnotation state shape as the
+ * full and fast graphs, enabling checkpointing, resume, and identical
+ * worker lifecycle handling.
+ *
+ * Unlike the full SDLC graph which uses executeNode() with approval gates,
+ * the exploration graph uses custom node functions with shared utilities
+ * (retryExecute, createNodeLogger). The feedback loop is driven by
+ * LangGraph interrupt/resume — the same mechanism used for approval gates.
+ */
+import { StateGraph, START } from '@langchain/langgraph';
+import { FeatureAgentAnnotation } from './state.js';
+import { createPrototypeGenerateNode } from './nodes/prototype-generate.node.js';
+import { createApplyFeedbackNode } from './nodes/apply-feedback.node.js';
+// Re-export for consumers
+export { FeatureAgentAnnotation } from './state.js';
+/**
+ * Routing function that determines the next node after prototype-generate
+ * resumes from interrupt.
+ *
+ * The resume payload (set via Command({update})) controls the flow:
+ * - _approvalAction === 'rejected' → apply-feedback (iterate with feedback)
+ * - _approvalAction === 'approved' or any other → END (promote or discard)
+ *
+ * The 'rejected' action maps to the iterate flow because the existing
+ * worker resume logic already sets _approvalAction='rejected' and
+ * _rejectionFeedback=<text> for rejection payloads. For exploration,
+ * "rejected" means "iterate with feedback" rather than "rejected for merge".
+ */
+export function routeAfterPrototypeGenerate(state) {
+    // If the user provided feedback (rejection = iterate in exploration context)
+    if (state._approvalAction === 'rejected') {
+        return 'apply-feedback';
+    }
+    // Otherwise: approved = promote/discard = exit the loop
+    return '__end__';
+}
+/**
+ * Factory function that creates and compiles the exploration-mode agent graph.
+ *
+ * The graph defines a feedback loop:
+ *   START → prototype-generate → (interrupt) → route:
+ *     - iterate: → apply-feedback → prototype-generate (loop)
+ *     - promote/discard: → END
+ *
+ * @param depsOrExecutor - Graph dependencies or a legacy executor
+ * @param checkpointer - Optional checkpoint saver for state persistence
+ * @returns A compiled LangGraph ready to be invoked
+ */
+export function createExplorationAgentGraph(depsOrExecutor, checkpointer) {
+    // Support legacy signature: createExplorationAgentGraph(executor, checkpointer)
+    const deps = 'execute' in depsOrExecutor ? { executor: depsOrExecutor } : depsOrExecutor;
+    const { executor } = deps;
+    const graph = new StateGraph(FeatureAgentAnnotation)
+        .addNode('prototype-generate', createPrototypeGenerateNode(executor))
+        .addNode('apply-feedback', createApplyFeedbackNode());
+    // START → prototype-generate
+    graph.addEdge(START, 'prototype-generate');
+    // prototype-generate → conditional routing (after resume from interrupt)
+    graph.addConditionalEdges('prototype-generate', routeAfterPrototypeGenerate);
+    // apply-feedback → prototype-generate (loop back)
+    graph.addEdge('apply-feedback', 'prototype-generate');
+    return graph.compile({ checkpointer });
+}

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/fast-feature-agent-graph.d.ts CHANGED Viewed

@@ -69,6 +69,10 @@ export declare function createFastFeatureAgentGraph(depsOrExecutor: FastFeatureA
     ciFixAttempts: number;
     ciFixHistory: import("../../../../domain/index.js").CiFixRecord[];
     ciFixStatus: "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted";
+    iterationCount: number;
+    maxIterations: number;
+    feedbackHistory: string[];
+    explorationStatus: "generating" | "waiting-feedback" | "applying-feedback" | "promoting" | "discarding" | undefined;
 }, {
     featureId?: string | undefined;
     repositoryPath?: string | undefined;
@@ -102,6 +106,10 @@ export declare function createFastFeatureAgentGraph(depsOrExecutor: FastFeatureA
     ciFixAttempts?: number | undefined;
     ciFixHistory?: import("../../../../domain/index.js").CiFixRecord[] | undefined;
     ciFixStatus?: "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted" | undefined;
+    iterationCount?: number | undefined;
+    maxIterations?: number | undefined;
+    feedbackHistory?: string[] | undefined;
+    explorationStatus?: "generating" | "waiting-feedback" | "applying-feedback" | "promoting" | "discarding" | undefined;
 }, "__start__" | "fast-implement", {
     featureId: {
         (): import("@langchain/langgraph").LastValue<string>;
@@ -155,6 +163,10 @@ export declare function createFastFeatureAgentGraph(depsOrExecutor: FastFeatureA
     ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
     ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
     ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
+    iterationCount: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+    maxIterations: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+    feedbackHistory: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    explorationStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"generating" | "waiting-feedback" | "applying-feedback" | "promoting" | "discarding" | undefined, "generating" | "waiting-feedback" | "applying-feedback" | "promoting" | "discarding" | undefined>;
 }, {
     featureId: {
         (): import("@langchain/langgraph").LastValue<string>;
@@ -208,6 +220,10 @@ export declare function createFastFeatureAgentGraph(depsOrExecutor: FastFeatureA
     ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
     ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
     ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
+    iterationCount: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+    maxIterations: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+    feedbackHistory: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    explorationStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"generating" | "waiting-feedback" | "applying-feedback" | "promoting" | "discarding" | undefined, "generating" | "waiting-feedback" | "applying-feedback" | "promoting" | "discarding" | undefined>;
 }, import("@langchain/langgraph").StateDefinition, {
     "fast-implement": Partial<import("@langchain/langgraph").StateType<{
         featureId: {
@@ -262,6 +278,10 @@ export declare function createFastFeatureAgentGraph(depsOrExecutor: FastFeatureA
         ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
         ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<import("../../../../domain/index.js").CiFixRecord[], import("../../../../domain/index.js").CiFixRecord[]>;
         ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
+        iterationCount: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        maxIterations: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+        feedbackHistory: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        explorationStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"generating" | "waiting-feedback" | "applying-feedback" | "promoting" | "discarding" | undefined, "generating" | "waiting-feedback" | "applying-feedback" | "promoting" | "discarding" | undefined>;
     }>>;
 }, unknown, unknown>;
 //# sourceMappingURL=fast-feature-agent-graph.d.ts.map

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/fast-feature-agent-graph.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"fast-feature-agent-graph.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/fast-feature-agent-graph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAA0B,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AACxF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AAGpG,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAGlF,OAAO,EAAE,sBAAsB,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE5E;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,cAAc,CAAC;IACzB,aAAa,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;CACjD;AAkBD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CACzC,cAAc,EAAE,yBAAyB,GAAG,cAAc,EAC1D,YAAY,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6BnC"}
1	+ {"version":3,"file":"fast-feature-agent-graph.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/fast-feature-agent-graph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAA0B,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AACxF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AAGpG,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAGlF,OAAO,EAAE,sBAAsB,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE5E;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,cAAc,CAAC;IACzB,aAAa,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;CACjD;AAkBD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CACzC,cAAc,EAAE,yBAAyB,GAAG,cAAc,EAC1D,YAAY,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6BnC"}