edsger 0.45.1 → 0.47.0

package/dist/services/lifecycle-agent/types.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Lifecycle Agent Types
+ *
+ * Type definitions for the AI-powered lifecycle agent that manages
+ * product feature lifecycle decisions: when to advance to the next phase,
+ * when to re-run the current phase, and when to escalate to a human.
+ *
+ * The lifecycle agent evaluates phase outputs against quality criteria
+ * and makes transition decisions, reducing reliance on manual human
+ * intervention while preserving the ability to escalate when needed.
+ */
+import type { FeatureStatus } from '../../types/index.js';
+import type { ExecutionMode } from '../../types/pipeline.js';
+/**
+ * Decision the lifecycle agent can make after evaluating a phase
+ *
+ * - advance: Phase output meets quality criteria, proceed to next phase
+ * - rerun: Phase output needs improvement, re-run with generated feedback
+ * - escalate: Agent is uncertain or output requires human judgment
+ */
+export type LifecycleDecision = 'advance' | 'rerun' | 'escalate';
+/**
+ * Result of evaluating a single quality criterion
+ */
+export interface CriterionEvaluation {
+    /** Criterion identifier matching a CriterionDefinition.id */
+    readonly criterionId: string;
+    /** Score from 0-100 for this criterion */
+    readonly score: number;
+    /** Whether the criterion meets its minimum threshold */
+    readonly passed: boolean;
+    /** Explanation of the evaluation result */
+    readonly reasoning: string;
+    /** Specific issues found, if any */
+    readonly issues?: readonly string[];
+}
+/**
+ * Complete evaluation result for a phase execution
+ * This is the primary output of the lifecycle agent's evaluation step
+ */
+export interface PhaseEvaluationResult {
+    /** The phase that was evaluated */
+    readonly phase: string;
+    /** Feature being evaluated */
+    readonly featureId: string;
+    /** Overall quality score (weighted average of criteria scores, 0-100) */
+    readonly qualityScore: number;
+    /** Decision: advance, rerun, or escalate */
+    readonly decision: LifecycleDecision;
+    /** Agent's confidence in its decision (0-100) */
+    readonly confidence: number;
+    /** Individual criterion evaluations */
+    readonly criteria: readonly CriterionEvaluation[];
+    /** Summary reasoning for the decision */
+    readonly reasoning: string;
+    /** If decision is 'rerun', suggested feedbacks to inject */
+    readonly suggestedFeedbacks?: readonly SuggestedFeedback[];
+    /** How many times this phase has been re-run in the current cycle */
+    readonly rerunCount: number;
+    /** Timestamp of the evaluation */
+    readonly evaluatedAt: string;
+}
+/**
+ * Feedback suggested by the lifecycle agent when deciding to re-run a phase
+ * These mirror the existing Feedback structure so they can be injected
+ * into the feedback system seamlessly
+ */
+export interface SuggestedFeedback {
+    /** Type of feedback, matching existing FeedbackType */
+    readonly feedbackType: 'requirement' | 'constraint' | 'preference' | 'context' | 'quality_criteria' | 'issue' | 'suggestion';
+    /** Short title describing the feedback */
+    readonly title: string;
+    /** Detailed content of the feedback */
+    readonly content: string;
+    /** Priority from 1-10 (higher = more important) */
+    readonly priority: number;
+    /** Which phase this feedback targets */
+    readonly phase: string;
+}
+/**
+ * Definition of a quality criterion for phase evaluation
+ * Each phase has its own set of criteria that the agent uses to evaluate outputs
+ */
+export interface CriterionDefinition {
+    /** Unique identifier for this criterion */
+    readonly id: string;
+    /** Human-readable name */
+    readonly name: string;
+    /** Description of what this criterion measures */
+    readonly description: string;
+    /** Relative importance weight (0-1, all weights for a phase should sum to ~1) */
+    readonly weight: number;
+    /** Minimum score (0-100) needed to pass this criterion */
+    readonly minimumScore: number;
+    /** Prompt instructions for how the AI should evaluate this criterion */
+    readonly evaluationGuidance: string;
+}
+/**
+ * Quality criteria configuration for a specific phase
+ * Defines the thresholds and criteria used to evaluate that phase's outputs
+ */
+export interface PhaseQualityCriteria {
+    /** Phase name (underscore format, e.g., 'user_stories_analysis') */
+    readonly phase: string;
+    /** Minimum overall quality score needed to auto-advance (0-100) */
+    readonly advanceThreshold: number;
+    /** Overall score below which the agent should escalate to human (0-100) */
+    readonly escalateThreshold: number;
+    /** Maximum number of automatic re-runs before escalating */
+    readonly maxAutoRetries: number;
+    /** Individual quality criteria for this phase */
+    readonly criteria: readonly CriterionDefinition[];
+}
+/**
+ * A transition rule that maps phase evaluation outcomes to actions
+ */
+export interface TransitionRule {
+    /** Phase this rule applies to (underscore format) */
+    readonly fromPhase: string;
+    /** Target phase if advancing */
+    readonly toPhase: string;
+    /** Execution mode to use when advancing to the target phase */
+    readonly executionMode: ExecutionMode;
+    /** Feature status to set when advancing */
+    readonly targetStatus: FeatureStatus;
+}
+/**
+ * Configuration for the lifecycle agent
+ * Controls behavior and thresholds for automated lifecycle management
+ */
+export interface LifecycleAgentConfig {
+    /** Whether the lifecycle agent is enabled for this product */
+    readonly enabled: boolean;
+    /** Allow agent to auto-advance phases without human approval */
+    readonly autoAdvanceEnabled: boolean;
+    /** Allow agent to auto-rerun phases with generated feedback */
+    readonly autoRerunEnabled: boolean;
+    /** Global maximum auto-retries (overrides per-phase if lower) */
+    readonly maxAutoRetries: number;
+    /** When confidence is below this threshold, always escalate (0-100) */
+    readonly confidenceThreshold: number;
+    /** Per-phase quality criteria overrides (falls back to defaults if not set) */
+    readonly phaseOverrides?: Partial<Record<string, Partial<PhaseQualityCriteria>>>;
+}
+/**
+ * Runtime state for the lifecycle agent managing a specific feature
+ * Tracks re-run counts and evaluation history
+ */
+export interface LifecycleAgentState {
+    /** Feature being managed */
+    readonly featureId: string;
+    /** Number of re-runs per phase in current cycle */
+    readonly rerunCounts: Readonly<Record<string, number>>;
+    /** History of evaluation results */
+    readonly evaluationHistory: readonly PhaseEvaluationResult[];
+}
+/**
+ * Input to the lifecycle agent's evaluate function
+ * Contains all context needed to evaluate a phase's output
+ */
+export interface PhaseEvaluationInput {
+    /** Feature ID */
+    readonly featureId: string;
+    /** Phase that was just executed */
+    readonly phase: string;
+    /** Current feature status */
+    readonly currentStatus: FeatureStatus;
+    /** The phase execution result data (varies by phase) */
+    readonly phaseOutput: unknown;
+    /** Quality criteria to evaluate against */
+    readonly qualityCriteria: PhaseQualityCriteria;
+    /** Current re-run count for this phase */
+    readonly rerunCount: number;
+    /** Agent configuration */
+    readonly config: LifecycleAgentConfig;
+}
+/**
+ * Output from the lifecycle agent's decide function
+ * Contains the decision and all information needed to execute it
+ */
+export interface LifecycleDecisionResult {
+    /** The evaluation that led to this decision */
+    readonly evaluation: PhaseEvaluationResult;
+    /** The transition to execute if advancing */
+    readonly transition?: TransitionRule;
+    /** Execution mode to use (for both advance and rerun scenarios) */
+    readonly executionMode?: ExecutionMode;
+    /** Feature status to set */
+    readonly targetStatus?: FeatureStatus;
+}

package/dist/services/lifecycle-agent/types.js

@@ -0,0 +1,12 @@
+/**
+ * Lifecycle Agent Types
+ *
+ * Type definitions for the AI-powered lifecycle agent that manages
+ * product feature lifecycle decisions: when to advance to the next phase,
+ * when to re-run the current phase, and when to escalate to a human.
+ *
+ * The lifecycle agent evaluates phase outputs against quality criteria
+ * and makes transition decisions, reducing reliance on manual human
+ * intervention while preserving the ability to escalate when needed.
+ */
+export {};

package/dist/services/phase-hooks/__tests__/bindings-fetcher.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/phase-hooks/__tests__/bindings-fetcher.test.js

@@ -0,0 +1,122 @@
+import assert from 'node:assert';
+import { afterEach, describe, it } from 'node:test';
+import { cacheBindings, clearBindingsCache, getBindingsForPhase, getCachedBindings, } from '../bindings-fetcher.js';
+function makeBinding(overrides = {}) {
+    return {
+        id: 'hook-1',
+        product_id: 'prod-1',
+        phase: 'technical-design',
+        hook_point: 'after',
+        plugin_name: 'payload-cms',
+        skill_name: 'validate-schema',
+        on_failure: 'block',
+        config: {},
+        sort_order: 0,
+        enabled: true,
+        ...overrides,
+    };
+}
+// ---- getBindingsForPhase ----
+void describe('getBindingsForPhase', () => {
+    void it('filters by exact phase match', () => {
+        const bindings = [
+            makeBinding({ phase: 'technical-design', hook_point: 'after' }),
+            makeBinding({
+                id: '2',
+                phase: 'code-implementation',
+                hook_point: 'after',
+            }),
+        ];
+        const result = getBindingsForPhase(bindings, 'technical-design', 'after');
+        assert.strictEqual(result.length, 1);
+        assert.strictEqual(result[0].phase, 'technical-design');
+    });
+    void it('matches wildcard phase "*"', () => {
+        const bindings = [
+            makeBinding({ phase: '*', hook_point: 'after', skill_name: 'notify' }),
+        ];
+        const result = getBindingsForPhase(bindings, 'code-review', 'after');
+        assert.strictEqual(result.length, 1);
+        assert.strictEqual(result[0].skill_name, 'notify');
+    });
+    void it('combines exact match and wildcard', () => {
+        const bindings = [
+            makeBinding({
+                id: '1',
+                phase: 'technical-design',
+                hook_point: 'after',
+                sort_order: 1,
+            }),
+            makeBinding({ id: '2', phase: '*', hook_point: 'after', sort_order: 0 }),
+        ];
+        const result = getBindingsForPhase(bindings, 'technical-design', 'after');
+        assert.strictEqual(result.length, 2);
+        // Wildcard (sort_order 0) comes first
+        assert.strictEqual(result[0].id, '2');
+        assert.strictEqual(result[1].id, '1');
+    });
+    void it('filters by hook_point', () => {
+        const bindings = [
+            makeBinding({ hook_point: 'before' }),
+            makeBinding({ id: '2', hook_point: 'after' }),
+        ];
+        const result = getBindingsForPhase(bindings, 'technical-design', 'before');
+        assert.strictEqual(result.length, 1);
+        assert.strictEqual(result[0].hook_point, 'before');
+    });
+    void it('excludes disabled bindings', () => {
+        const bindings = [makeBinding({ enabled: false })];
+        const result = getBindingsForPhase(bindings, 'technical-design', 'after');
+        assert.strictEqual(result.length, 0);
+    });
+    void it('sorts by sort_order ascending', () => {
+        const bindings = [
+            makeBinding({ id: 'c', sort_order: 10 }),
+            makeBinding({ id: 'a', sort_order: 1 }),
+            makeBinding({ id: 'b', sort_order: 5 }),
+        ];
+        const result = getBindingsForPhase(bindings, 'technical-design', 'after');
+        assert.deepStrictEqual(result.map((b) => b.id), ['a', 'b', 'c']);
+    });
+    void it('returns empty array when no bindings match', () => {
+        const bindings = [
+            makeBinding({ phase: 'code-review', hook_point: 'before' }),
+        ];
+        const result = getBindingsForPhase(bindings, 'technical-design', 'after');
+        assert.strictEqual(result.length, 0);
+    });
+    void it('handles on_error hook point', () => {
+        const bindings = [makeBinding({ hook_point: 'on_error' })];
+        const result = getBindingsForPhase(bindings, 'technical-design', 'on_error');
+        assert.strictEqual(result.length, 1);
+    });
+});
+// ---- Cache management ----
+void describe('bindings cache', () => {
+    afterEach(() => {
+        clearBindingsCache('test-feature-1');
+        clearBindingsCache('test-feature-2');
+    });
+    void it('returns null for uncached feature', () => {
+        assert.strictEqual(getCachedBindings('nonexistent'), null);
+    });
+    void it('round-trips cache/get/clear', () => {
+        const bindings = [makeBinding()];
+        cacheBindings('test-feature-1', 'prod-1', bindings);
+        const cached = getCachedBindings('test-feature-1');
+        assert.ok(cached);
+        assert.strictEqual(cached.productId, 'prod-1');
+        assert.strictEqual(cached.bindings.length, 1);
+        assert.ok(cached.fetchedAt > 0);
+        clearBindingsCache('test-feature-1');
+        assert.strictEqual(getCachedBindings('test-feature-1'), null);
+    });
+    void it('isolates cache by featureId', () => {
+        cacheBindings('test-feature-1', 'prod-1', [makeBinding({ id: 'a' })]);
+        cacheBindings('test-feature-2', 'prod-2', [makeBinding({ id: 'b' })]);
+        const cached1 = getCachedBindings('test-feature-1');
+        const cached2 = getCachedBindings('test-feature-2');
+        assert.strictEqual(cached1?.bindings[0].id, 'a');
+        assert.strictEqual(cached2?.bindings[0].id, 'b');
+    });
+});

package/dist/services/phase-hooks/__tests__/hook-executor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/phase-hooks/__tests__/hook-executor.test.js

@@ -0,0 +1,321 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { buildHookPrompt, executeHook, parseHookResponse, } from '../hook-executor.js';
+function makeBinding(overrides = {}) {
+    return {
+        id: 'hook-1',
+        product_id: 'prod-1',
+        phase: 'technical-design',
+        hook_point: 'after',
+        plugin_name: 'payload-cms',
+        skill_name: 'validate-schema',
+        on_failure: 'block',
+        config: {},
+        sort_order: 0,
+        enabled: true,
+        ...overrides,
+    };
+}
+const defaultSkillFile = {
+    frontmatter: { model: 'sonnet', maxTurns: 10 },
+    body: 'You are a schema validator.',
+};
+function makeContext(overrides = {}) {
+    return {
+        featureId: 'feat-1',
+        phase: 'technical-design',
+        hookPoint: 'after',
+        ...overrides,
+    };
+}
+// ---- buildHookPrompt ----
+void describe('buildHookPrompt', () => {
+    void it('includes feature ID and phase name', () => {
+        const ctx = {
+            featureId: 'feat-123',
+            phase: 'technical-design',
+            hookPoint: 'after',
+        };
+        const prompt = buildHookPrompt(makeBinding(), ctx);
+        assert.ok(prompt.includes('feat-123'));
+        assert.ok(prompt.includes('technical-design'));
+    });
+    void it('includes plugin and skill names', () => {
+        const ctx = {
+            featureId: 'feat-1',
+            phase: 'code-review',
+            hookPoint: 'before',
+        };
+        const prompt = buildHookPrompt(makeBinding(), ctx);
+        assert.ok(prompt.includes('payload-cms'));
+        assert.ok(prompt.includes('validate-schema'));
+    });
+    void it('includes hook point', () => {
+        const ctx = {
+            featureId: 'feat-1',
+            phase: 'code-review',
+            hookPoint: 'before',
+        };
+        const prompt = buildHookPrompt(makeBinding(), ctx);
+        assert.ok(prompt.includes('before'));
+    });
+    void it('includes phase result for after hooks', () => {
+        const ctx = {
+            featureId: 'feat-1',
+            phase: 'technical-design',
+            hookPoint: 'after',
+            phaseResult: { status: 'success', iterations: 3 },
+        };
+        const prompt = buildHookPrompt(makeBinding(), ctx);
+        assert.ok(prompt.includes('Phase Result'));
+        assert.ok(prompt.includes('"iterations": 3'));
+    });
+    void it('does not include phase result for before hooks', () => {
+        const ctx = {
+            featureId: 'feat-1',
+            phase: 'technical-design',
+            hookPoint: 'before',
+        };
+        const prompt = buildHookPrompt(makeBinding(), ctx);
+        assert.ok(!prompt.includes('Phase Result'));
+    });
+    void it('includes error for on_error hooks', () => {
+        const ctx = {
+            featureId: 'feat-1',
+            phase: 'code-implementation',
+            hookPoint: 'on_error',
+            error: new Error('Out of memory'),
+        };
+        const prompt = buildHookPrompt(makeBinding(), ctx);
+        assert.ok(prompt.includes('Phase Error'));
+        assert.ok(prompt.includes('Out of memory'));
+    });
+    void it('includes binding config when present', () => {
+        const binding = makeBinding({
+            config: { severity: 'high', threshold: 0.8 },
+        });
+        const ctx = {
+            featureId: 'feat-1',
+            phase: 'technical-design',
+            hookPoint: 'after',
+        };
+        const prompt = buildHookPrompt(binding, ctx);
+        assert.ok(prompt.includes('Hook Configuration'));
+        assert.ok(prompt.includes('"severity": "high"'));
+    });
+    void it('omits config section when config is empty', () => {
+        const ctx = {
+            featureId: 'feat-1',
+            phase: 'technical-design',
+            hookPoint: 'after',
+        };
+        const prompt = buildHookPrompt(makeBinding(), ctx);
+        assert.ok(!prompt.includes('Hook Configuration'));
+    });
+});
+// ---- parseHookResponse ----
+void describe('parseHookResponse', () => {
+    void it('parses JSON in fenced code block', () => {
+        const text = 'Some text\n```json\n{"status":"success","message":"All good","data":{"count":5}}\n```\nMore text';
+        const result = parseHookResponse(text);
+        assert.strictEqual(result.status, 'success');
+        assert.strictEqual(result.message, 'All good');
+        assert.deepStrictEqual(result.data, { count: 5 });
+    });
+    void it('parses raw JSON text', () => {
+        const text = '{"status":"error","message":"Schema mismatch"}';
+        const result = parseHookResponse(text);
+        assert.strictEqual(result.status, 'error');
+        assert.strictEqual(result.message, 'Schema mismatch');
+    });
+    void it('treats non-JSON text as success', () => {
+        const text = 'Everything looks fine, no issues found.';
+        const result = parseHookResponse(text);
+        assert.strictEqual(result.status, 'success');
+        assert.ok(result.message.includes('Everything looks fine'));
+    });
+    void it('truncates long non-JSON text', () => {
+        const text = 'x'.repeat(1000);
+        const result = parseHookResponse(text);
+        assert.strictEqual(result.message.length, 500);
+    });
+    void it('handles empty text', () => {
+        const result = parseHookResponse('');
+        assert.strictEqual(result.status, 'success');
+        assert.ok(result.message.includes('no structured output'));
+    });
+    void it('handles malformed JSON in code block gracefully', () => {
+        const text = '```json\n{invalid json}\n```';
+        const result = parseHookResponse(text);
+        assert.strictEqual(result.status, 'success');
+    });
+    void it('defaults message when JSON has no message field', () => {
+        const text = '{"status":"success"}';
+        const result = parseHookResponse(text);
+        assert.strictEqual(result.message, 'Hook completed');
+    });
+});
+// ---- executeHook (with injected deps) ----
+void describe('executeHook', () => {
+    /** Create a mock queryFn that yields the given messages */
+    function mockQuery(messages
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) {
+        // Return a function that returns an async iterable
+        return () => ({
+            // eslint-disable-next-line @typescript-eslint/require-await
+            async *[Symbol.asyncIterator]() {
+                for (const msg of messages) {
+                    yield msg;
+                }
+            },
+        });
+    }
+    function makeDeps(overrides = {}) {
+        return {
+            loadSkillFile: () => Promise.resolve(defaultSkillFile),
+            queryFn: mockQuery([
+                {
+                    type: 'result',
+                    subtype: 'success',
+                    result: '```json\n{"status":"success","message":"Schema valid"}\n```',
+                },
+            ]),
+            ...overrides,
+        };
+    }
+    void it('returns skipped when skill file not found', async () => {
+        const deps = makeDeps({ loadSkillFile: () => Promise.resolve(null) });
+        const result = await executeHook(makeBinding(), makeContext(), false, deps);
+        assert.strictEqual(result.status, 'skipped');
+        assert.ok(result.message.includes('not found'));
+    });
+    void it('executes successfully with result message from query', async () => {
+        const deps = makeDeps();
+        const result = await executeHook(makeBinding(), makeContext(), false, deps);
+        assert.strictEqual(result.status, 'success');
+        assert.strictEqual(result.message, 'Schema valid');
+        assert.ok(result.duration_ms >= 0);
+        assert.strictEqual(result.hookId, 'hook-1');
+    });
+    void it('returns error status when skill returns error JSON', async () => {
+        const deps = makeDeps({
+            queryFn: mockQuery([
+                {
+                    type: 'result',
+                    subtype: 'success',
+                    result: '{"status":"error","message":"3 issues found"}',
+                },
+            ]),
+        });
+        const result = await executeHook(makeBinding(), makeContext(), false, deps);
+        assert.strictEqual(result.status, 'error');
+        assert.strictEqual(result.message, '3 issues found');
+    });
+    void it('collects text from assistant messages', async () => {
+        const deps = makeDeps({
+            queryFn: mockQuery([
+                {
+                    type: 'assistant',
+                    message: {
+                        content: [{ type: 'text', text: '```json\n{"status":"success",' }],
+                    },
+                },
+                {
+                    type: 'assistant',
+                    message: {
+                        content: [
+                            { type: 'text', text: '"message":"from streaming"}\n```' },
+                        ],
+                    },
+                },
+                { type: 'result', subtype: 'success', result: '' },
+            ]),
+        });
+        const result = await executeHook(makeBinding(), makeContext(), false, deps);
+        assert.strictEqual(result.status, 'success');
+        assert.strictEqual(result.message, 'from streaming');
+    });
+    void it('prefers result message over streamed text', async () => {
+        const deps = makeDeps({
+            queryFn: mockQuery([
+                {
+                    type: 'assistant',
+                    message: { content: [{ type: 'text', text: 'streamed partial' }] },
+                },
+                {
+                    type: 'result',
+                    subtype: 'success',
+                    result: '{"status":"success","message":"final result"}',
+                },
+            ]),
+        });
+        const result = await executeHook(makeBinding(), makeContext(), false, deps);
+        assert.strictEqual(result.message, 'final result');
+    });
+    void it('returns error when query throws', async () => {
+        const deps = makeDeps({
+            queryFn: (() => {
+                throw new Error('Network timeout');
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }),
+        });
+        const result = await executeHook(makeBinding(), makeContext(), false, deps);
+        assert.strictEqual(result.status, 'error');
+        assert.ok(result.message.includes('Network timeout'));
+    });
+    void it('passes correct model and maxTurns from frontmatter', async () => {
+        let capturedOptions = {};
+        const deps = makeDeps({
+            loadSkillFile: () => Promise.resolve({
+                frontmatter: { model: 'haiku', maxTurns: 5 },
+                body: 'Test prompt',
+            }),
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            queryFn: ((opts) => {
+                capturedOptions = opts.options;
+                return {
+                    // eslint-disable-next-line @typescript-eslint/require-await
+                    async *[Symbol.asyncIterator]() {
+                        yield {
+                            type: 'result',
+                            subtype: 'success',
+                            result: '{"status":"success","message":"ok"}',
+                        };
+                    },
+                };
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }),
+        });
+        await executeHook(makeBinding(), makeContext(), false, deps);
+        assert.strictEqual(capturedOptions.model, 'haiku');
+        assert.strictEqual(capturedOptions.maxTurns, 5);
+    });
+    void it('uses DEFAULT_MODEL when frontmatter has no model', async () => {
+        let capturedOptions = {};
+        const deps = makeDeps({
+            loadSkillFile: () => Promise.resolve({
+                frontmatter: {},
+                body: 'Test prompt',
+            }),
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            queryFn: ((opts) => {
+                capturedOptions = opts.options;
+                return {
+                    // eslint-disable-next-line @typescript-eslint/require-await
+                    async *[Symbol.asyncIterator]() {
+                        yield {
+                            type: 'result',
+                            subtype: 'success',
+                            result: '{"status":"success","message":"ok"}',
+                        };
+                    },
+                };
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }),
+        });
+        await executeHook(makeBinding(), makeContext(), false, deps);
+        // DEFAULT_MODEL is 'opus'
+        assert.strictEqual(capturedOptions.model, 'opus');
+    });
+});

package/dist/services/phase-hooks/__tests__/hook-runner.test.d.ts

@@ -0,0 +1 @@
+export {};