@telora/factory 0.4.5

package/dist/strategy-design-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy-design-schema.d.ts","sourceRoot":"","sources":["../src/strategy-design-schema.ts"],"names":[],"mappings":"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"}

package/dist/strategy-design-schema.js

@@ -0,0 +1,126 @@
+/**
+ * Strategy design types, Zod schemas, and dependency validation.
+ *
+ * Pure data definitions and validation logic for AI-generated strategy designs.
+ * No side effects, no I/O -- safe to import from any module.
+ */
+import { z } from 'zod';
+// ============================================================================
+// Zod schemas for AI output validation
+// ============================================================================
+export const ContractItemSchema = z.object({
+    kind: z.enum(['file', 'export', 'api_endpoint', 'db_table', 'type']),
+    identifier: z.string().min(1),
+    description: z.string().optional(),
+});
+export const StrategyContractSchema = z.object({
+    produces: z.array(ContractItemSchema),
+    consumes: z.array(ContractItemSchema),
+});
+export const InterfaceContractSchema = z.object({
+    name: z.string().min(1),
+    provider: z.string().min(1),
+    consumer: z.string().min(1),
+    description: z.string().min(1),
+});
+export const StrategyDesignUnitSchema = z.object({
+    tempId: z.string().min(1),
+    name: z.string().min(1).max(200),
+    description: z.string().min(1),
+    techContext: z.string().min(1),
+    priorityRank: z.number().int().min(0),
+    dependsOn: z.array(z.string()),
+    interfaceContract: StrategyContractSchema,
+});
+export const StrategyDesignPlanSchema = z.object({
+    strategies: z.array(StrategyDesignUnitSchema).min(1),
+    interfaceContracts: z.array(InterfaceContractSchema),
+    summary: z.string().min(1),
+});
+/** Zod schema for validating getStrategiesByFactoryInstance response. */
+export const PersistedStrategySchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    description: z.string().nullable(),
+    techContext: z.string().nullable(),
+    priorityRank: z.number(),
+    status: z.string(),
+    executionStatus: z.enum(['pending', 'in_progress', 'completed', 'failed', 'gating_deterministic', 'gating_behavioral', 'gating_adversarial', 'gate_fix_pending']).nullable(),
+    interfaceContract: z.object({
+        produces: z.array(ContractItemSchema),
+        consumes: z.array(ContractItemSchema),
+    }).nullable(),
+    dependsOn: z.array(z.string()),
+    gateFixStartedAt: z.string().nullable().optional().default(null),
+});
+export const GetInstanceStrategiesResponseSchema = z.object({
+    strategies: z.array(PersistedStrategySchema),
+});
+// ============================================================================
+// Dependency validation
+// ============================================================================
+/**
+ * Validate that all dependsOn references point to valid tempIds within the plan,
+ * and that interface contract provider/consumer references are valid.
+ *
+ * Also checks for self-dependencies and cycles (via topological sort).
+ * Returns an error message if validation fails, null if valid.
+ */
+export function validateStrategyDependencies(plan) {
+    const validTempIds = new Set(plan.strategies.map((s) => s.tempId));
+    // Check for duplicate tempIds
+    if (validTempIds.size !== plan.strategies.length) {
+        return 'Duplicate tempId found in strategies';
+    }
+    // Validate dependsOn references
+    for (const strategy of plan.strategies) {
+        for (const dep of strategy.dependsOn) {
+            if (!validTempIds.has(dep)) {
+                return `Strategy "${strategy.tempId}" references unknown dependency "${dep}"`;
+            }
+        }
+        if (strategy.dependsOn.includes(strategy.tempId)) {
+            return `Strategy "${strategy.tempId}" has a self-dependency`;
+        }
+    }
+    // Validate interface contract references
+    for (const contract of plan.interfaceContracts) {
+        if (!validTempIds.has(contract.provider)) {
+            return `Interface contract "${contract.name}" references unknown provider "${contract.provider}"`;
+        }
+        if (!validTempIds.has(contract.consumer)) {
+            return `Interface contract "${contract.name}" references unknown consumer "${contract.consumer}"`;
+        }
+        if (contract.provider === contract.consumer) {
+            return `Interface contract "${contract.name}" has same provider and consumer "${contract.provider}"`;
+        }
+    }
+    // Topological sort to detect cycles
+    const visited = new Set();
+    const inStack = new Set();
+    const adjList = new Map();
+    for (const strategy of plan.strategies) {
+        adjList.set(strategy.tempId, strategy.dependsOn);
+    }
+    function hasCycle(node) {
+        if (inStack.has(node))
+            return true;
+        if (visited.has(node))
+            return false;
+        visited.add(node);
+        inStack.add(node);
+        for (const dep of adjList.get(node) ?? []) {
+            if (hasCycle(dep))
+                return true;
+        }
+        inStack.delete(node);
+        return false;
+    }
+    for (const strategy of plan.strategies) {
+        if (hasCycle(strategy.tempId)) {
+            return `Cycle detected in strategy dependencies involving "${strategy.tempId}"`;
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=strategy-design-schema.js.map

package/dist/strategy-design-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy-design-schema.js","sourceRoot":"","sources":["../src/strategy-design-schema.ts"],"names":[],"mappings":"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"}

package/dist/strategy-design.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Strategy design phase for factory instances.
+ *
+ * When an instance transitions to 'designing', this module:
+ * 1. Spawns Claude Code in --print mode to decompose the specification
+ *    into bounded strategies with dependency edges and interface contracts
+ * 2. Validates the AI output with Zod
+ * 3. Maps tempId references to real UUIDs for dependency edges
+ * 4. Persists strategies to product_strategies (linked via factory_instance_id)
+ * 5. Transitions the instance to 'planning' on success
+ *
+ * The implementation has been split into focused modules:
+ *   - strategy-design-schema.ts  -- types, Zod schemas, dependency validation
+ *   - strategy-design-prompt.ts  -- prompt builders
+ *   - strategy-design-graph.ts   -- dependency graph builder, contract validation
+ *
+ * This file contains generation, persistence, and orchestration logic,
+ * plus barrel re-exports from the split modules.
+ */
+import { type ParsedTokenUsage } from './queries/shared.js';
+import type { ResourceGovernor } from '@telora/daemon-core';
+import type { FactoryBlueprint, FactoryConfig, FactoryInstanceState } from './types.js';
+import type { StrategyDesignPlan, StrategyGenerationResult, StrategyMapping, PersistedStrategy } from './strategy-design-schema.js';
+export type { ContractItemKind, ContractItem, StrategyContract, InterfaceContract, StrategyDesignUnit, StrategyDesignPlan, StrategyGraphNode, StrategyDependencyGraph, ContractValidationResult, ContractMismatch, ContractWarning, StrategyMapping, StrategyExecutionStatus, PersistedStrategy, StrategyGenerationResult, StrategyGraphInput, } from './strategy-design-schema.js';
+export { ContractItemSchema, StrategyContractSchema, InterfaceContractSchema, StrategyDesignUnitSchema, StrategyDesignPlanSchema, PersistedStrategySchema, GetInstanceStrategiesResponseSchema, validateStrategyDependencies, } from './strategy-design-schema.js';
+export { buildStrategyDesignPrompt, buildStrategyRetryPrompt } from './strategy-design-prompt.js';
+export { buildStrategyDependencyGraph, validateInterfaceContracts } from './strategy-design-graph.js';
+/** Default timeout for the strategy design Claude Code session (5 minutes). */
+export declare const DEFAULT_STRATEGY_DESIGN_TIMEOUT_MS = 300000;
+/** Maximum number of retry attempts when strategy generation fails validation. */
+export declare const MAX_STRATEGY_DESIGN_RETRIES = 2;
+/**
+ * Spawn Claude Code and validate the resulting strategy design.
+ *
+ * Follows the same pattern as generateAndValidateWorkPlan() in planning.ts:
+ * - Spawns Claude Code in --print mode with the given prompt
+ * - Extracts and parses the JSON strategy design from the output
+ * - Validates schema, dependencies, and DAG structure
+ *
+ * Extracted as a standalone function so it can be called in a retry loop.
+ */
+export declare function generateAndValidateStrategyDesign(prompt: string, config: FactoryConfig, worktreePath: string, blueprint?: FactoryBlueprint): Promise<StrategyGenerationResult>;
+/**
+ * Map tempId references to real UUIDs and persist strategies as product_strategy rows.
+ *
+ * Creates product_strategy rows via the product-api edge function, linked to the
+ * factory instance via factory_instance_id.
+ *
+ * @returns Array of mappings from tempId to real strategy UUID.
+ */
+export declare function mapAndPersistStrategies(state: FactoryInstanceState, strategyDesign: StrategyDesignPlan): Promise<StrategyMapping[]>;
+/**
+ * Get strategies created by a factory instance (full data for planning).
+ */
+export declare function getStrategiesByFactoryInstance(instanceId: string): Promise<PersistedStrategy[]>;
+/**
+ * Run the full strategy design phase for a factory instance.
+ *
+ * Orchestrates: audit -> prompt -> generate -> validate -> persist -> transition.
+ * Called by runDesigning() in instance-lifecycle.ts.
+ *
+ * @returns An object indicating success or failure with an optional error message.
+ */
+export declare function runStrategyDesignPhase(state: FactoryInstanceState, config: FactoryConfig, governor?: ResourceGovernor | null): Promise<{
+    success: boolean;
+    error?: string;
+    tokenUsage?: ParsedTokenUsage | null;
+}>;
+//# sourceMappingURL=strategy-design.d.ts.map

package/dist/strategy-design.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy-design.d.ts","sourceRoot":"","sources":["../src/strategy-design.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAOH,OAAO,EAA4C,KAAK,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACtG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAMxF,OAAO,KAAK,EACV,kBAAkB,EAClB,wBAAwB,EACxB,eAAe,EACf,iBAAiB,EAClB,MAAM,6BAA6B,CAAC;AASrC,YAAY,EACV,gBAAgB,EAChB,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,uBAAuB,EACvB,wBAAwB,EACxB,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,uBAAuB,EACvB,iBAAiB,EACjB,wBAAwB,EACxB,kBAAkB,GACnB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,EACxB,wBAAwB,EACxB,uBAAuB,EACvB,mCAAmC,EACnC,4BAA4B,GAC7B,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AAGlG,OAAO,EAAE,4BAA4B,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAC;AAMtG,+EAA+E;AAC/E,eAAO,MAAM,kCAAkC,SAAU,CAAC;AAE1D,kFAAkF;AAClF,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAS7C;;;;;;;;;GASG;AACH,wBAAsB,iCAAiC,CACrD,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,aAAa,EACrB,YAAY,EAAE,MAAM,EACpB,SAAS,CAAC,EAAE,gBAAgB,GAC3B,OAAO,CAAC,wBAAwB,CAAC,CA2JnC;AAMD;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,oBAAoB,EAC3B,cAAc,EAAE,kBAAkB,GACjC,OAAO,CAAC,eAAe,EAAE,CAAC,CA2D5B;AAGD;;GAEG;AACH,wBAAsB,8BAA8B,CAClD,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAO9B;AAMD;;;;;;;GAOG;AACH,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,oBAAoB,EAC3B,MAAM,EAAE,aAAa,EACrB,QAAQ,CAAC,EAAE,gBAAgB,GAAG,IAAI,GACjC,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAA;CAAE,CAAC,CAoKrF"}

package/dist/strategy-design.js

@@ -0,0 +1,411 @@
+/**
+ * Strategy design phase for factory instances.
+ *
+ * When an instance transitions to 'designing', this module:
+ * 1. Spawns Claude Code in --print mode to decompose the specification
+ *    into bounded strategies with dependency edges and interface contracts
+ * 2. Validates the AI output with Zod
+ * 3. Maps tempId references to real UUIDs for dependency edges
+ * 4. Persists strategies to product_strategies (linked via factory_instance_id)
+ * 5. Transitions the instance to 'planning' on success
+ *
+ * The implementation has been split into focused modules:
+ *   - strategy-design-schema.ts  -- types, Zod schemas, dependency validation
+ *   - strategy-design-prompt.ts  -- prompt builders
+ *   - strategy-design-graph.ts   -- dependency graph builder, contract validation
+ *
+ * This file contains generation, persistence, and orchestration logic,
+ * plus barrel re-exports from the split modules.
+ */
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import { buildPlanningEnv, extractWorkPlanJson } from './planning.js';
+import { spawnAsync } from './process-runner.js';
+import { callApiValidated } from './queries/shared.js';
+import { parseTokenUsageFromOutput, sumTokenUsage } from './queries/shared.js';
+import { GetInstanceStrategiesResponseSchema, StrategyDesignPlanSchema, validateStrategyDependencies, } from './strategy-design-schema.js';
+import { buildStrategyDesignPrompt, buildStrategyRetryPrompt } from './strategy-design-prompt.js';
+import { buildStrategyDependencyGraph, validateInterfaceContracts } from './strategy-design-graph.js';
+export { ContractItemSchema, StrategyContractSchema, InterfaceContractSchema, StrategyDesignUnitSchema, StrategyDesignPlanSchema, PersistedStrategySchema, GetInstanceStrategiesResponseSchema, validateStrategyDependencies, } from './strategy-design-schema.js';
+// Prompt builders
+export { buildStrategyDesignPrompt, buildStrategyRetryPrompt } from './strategy-design-prompt.js';
+// Graph utilities
+export { buildStrategyDependencyGraph, validateInterfaceContracts } from './strategy-design-graph.js';
+// ============================================================================
+// Constants
+// ============================================================================
+/** Default timeout for the strategy design Claude Code session (5 minutes). */
+export const DEFAULT_STRATEGY_DESIGN_TIMEOUT_MS = 300_000;
+/** Maximum number of retry attempts when strategy generation fails validation. */
+export const MAX_STRATEGY_DESIGN_RETRIES = 2;
+/** Log prefix for this module. */
+const LOG_PREFIX = '[strategy-design]';
+// ============================================================================
+// Generation and validation
+// ============================================================================
+/**
+ * Spawn Claude Code and validate the resulting strategy design.
+ *
+ * Follows the same pattern as generateAndValidateWorkPlan() in planning.ts:
+ * - Spawns Claude Code in --print mode with the given prompt
+ * - Extracts and parses the JSON strategy design from the output
+ * - Validates schema, dependencies, and DAG structure
+ *
+ * Extracted as a standalone function so it can be called in a retry loop.
+ */
+export async function generateAndValidateStrategyDesign(prompt, config, worktreePath, blueprint) {
+    const timeoutMs = blueprint?.strategyDesignTimeoutMs ?? DEFAULT_STRATEGY_DESIGN_TIMEOUT_MS;
+    // -- Spawn Claude Code --
+    let rawOutput;
+    try {
+        const args = ['--print', '--output-format', 'json', '--verbose'];
+        const env = buildPlanningEnv(config);
+        console.log(`${LOG_PREFIX} Spawning Claude Code for strategy design generation...`);
+        rawOutput = await spawnAsync(config.claudeCodePath, args, {
+            input: prompt,
+            encoding: 'utf-8',
+            timeout: timeoutMs,
+            cwd: worktreePath,
+            env,
+        });
+    }
+    catch (err) {
+        const execErr = err;
+        if (execErr.killed || execErr.signal === 'SIGTERM') {
+            return { success: false, error: `Claude Code timed out after ${timeoutMs / 1000}s`, tokenUsage: null };
+        }
+        const stderr = execErr.stderr ? String(execErr.stderr).slice(0, 500) : '';
+        return {
+            success: false,
+            error: `Claude Code failed (exit ${execErr.status ?? 'unknown'}): ${execErr.message ?? 'unknown error'}${stderr ? ` | stderr: ${stderr}` : ''}`,
+            tokenUsage: null,
+        };
+    }
+    if (!rawOutput || rawOutput.trim().length === 0) {
+        return { success: false, error: 'Claude Code returned empty output', tokenUsage: null };
+    }
+    // Parse token usage from the NDJSON output (TEL-6: cost tracking for planner sessions)
+    const tokenUsage = parseTokenUsageFromOutput(rawOutput);
+    // -- Extract and validate the strategy design --
+    let designJson;
+    try {
+        designJson = extractWorkPlanJson(rawOutput);
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: `Failed to extract strategy design JSON: ${err instanceof Error ? err.message : String(err)}`,
+            tokenUsage,
+        };
+    }
+    let parsedJson;
+    try {
+        parsedJson = JSON.parse(designJson);
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: `Strategy design is not valid JSON: ${err instanceof Error ? err.message : String(err)}`,
+            tokenUsage,
+        };
+    }
+    // Normalize: AI sometimes returns a bare array instead of an object.
+    // If single-element array containing an object, unwrap it.
+    // If array of strategy-shaped items, wrap as { strategies: [...] }.
+    if (Array.isArray(parsedJson)) {
+        if (parsedJson.length === 1 && typeof parsedJson[0] === 'object' && parsedJson[0] !== null && !Array.isArray(parsedJson[0])) {
+            parsedJson = parsedJson[0];
+        }
+        else {
+            parsedJson = { strategies: parsedJson, interfaceContracts: [], summary: 'Auto-wrapped from array response' };
+        }
+    }
+    const validation = StrategyDesignPlanSchema.safeParse(parsedJson);
+    if (!validation.success) {
+        const issues = validation.error.issues
+            .map((i) => `${i.path.join('.')}: ${i.message}`)
+            .join('; ');
+        // Diagnostic: log top-level keys and first strategy item keys to diagnose field name mismatches
+        const topKeys = typeof parsedJson === 'object' && parsedJson !== null ? Object.keys(parsedJson) : [];
+        const obj = parsedJson;
+        const strategies = Array.isArray(obj.strategies) ? obj.strategies : [];
+        const firstItem = strategies.length > 0 && typeof strategies[0] === 'object' && strategies[0] !== null
+            ? Object.keys(strategies[0])
+            : [];
+        console.error(`${LOG_PREFIX} Validation failed. Top-level keys: [${topKeys}], strategies count: ${strategies.length}, first item keys: [${firstItem}]`);
+        if (strategies.length > 0) {
+            console.error(`${LOG_PREFIX} First strategy item: ${JSON.stringify(strategies[0]).slice(0, 500)}`);
+        }
+        return { success: false, error: `Strategy design validation failed: ${issues}`, tokenUsage };
+    }
+    const strategyDesign = validation.data;
+    console.log(`${LOG_PREFIX} Strategy design validated: ${strategyDesign.strategies.length} strategy(ies)`);
+    // -- Validate dependencies and DAG structure --
+    const depError = validateStrategyDependencies(strategyDesign);
+    if (depError) {
+        return { success: false, error: `Strategy dependency error: ${depError}`, tokenUsage };
+    }
+    // -- Validate interface contracts pre-persistence (using tempIds) --
+    // Check that every consumed artifact is produced by at least one dependency.
+    // This runs BEFORE persistence so contract errors are caught by the retry loop.
+    if (strategyDesign.strategies.length > 1) {
+        const producesMap = new Map(); // tempId -> Set<"kind:identifier">
+        for (const s of strategyDesign.strategies) {
+            const pSet = new Set();
+            for (const p of s.interfaceContract.produces) {
+                pSet.add(`${p.kind}:${p.identifier}`);
+            }
+            producesMap.set(s.tempId, pSet);
+        }
+        const contractErrors = [];
+        for (const s of strategyDesign.strategies) {
+            for (const consumed of s.interfaceContract.consumes) {
+                const key = `${consumed.kind}:${consumed.identifier}`;
+                let satisfied = false;
+                for (const depId of s.dependsOn) {
+                    const depProduces = producesMap.get(depId);
+                    if (depProduces?.has(key)) {
+                        satisfied = true;
+                        break;
+                    }
+                }
+                if (!satisfied) {
+                    const depNames = s.dependsOn
+                        .map((id) => strategyDesign.strategies.find((x) => x.tempId === id)?.name ?? id)
+                        .join(', ');
+                    contractErrors.push(`"${s.name}" consumes ${consumed.kind}:${consumed.identifier} but ` +
+                        `none of its dependencies (${depNames || 'none'}) produce it`);
+                }
+            }
+        }
+        if (contractErrors.length > 0) {
+            return {
+                success: false,
+                error: `Interface contract validation failed: ${contractErrors.join('; ')}`,
+                tokenUsage,
+            };
+        }
+    }
+    return { success: true, strategyDesign, tokenUsage };
+}
+// ============================================================================
+// Persistence: map tempIds and create product_strategies
+// ============================================================================
+/**
+ * Map tempId references to real UUIDs and persist strategies as product_strategy rows.
+ *
+ * Creates product_strategy rows via the product-api edge function, linked to the
+ * factory instance via factory_instance_id.
+ *
+ * @returns Array of mappings from tempId to real strategy UUID.
+ */
+export async function mapAndPersistStrategies(state, strategyDesign) {
+    // Build tempId -> UUID mapping
+    const idMap = new Map();
+    for (const strategy of strategyDesign.strategies) {
+        idMap.set(strategy.tempId, randomUUID());
+    }
+    // Build strategy rows for bulk insert
+    const strategies = strategyDesign.strategies.map((strategy) => ({
+        id: idMap.get(strategy.tempId),
+        name: strategy.name,
+        description: strategy.description,
+        techContext: strategy.techContext,
+        priorityRank: strategy.priorityRank,
+        dependsOn: strategy.dependsOn.map((tempId) => {
+            const realId = idMap.get(tempId);
+            if (!realId) {
+                throw new Error(`BUG: tempId "${tempId}" not found in idMap`);
+            }
+            return realId;
+        }),
+        interfaceContract: strategy.interfaceContract,
+    }));
+    // Persist via edge function (validated response)
+    const CreateStrategiesResponseSchema = z.object({
+        strategies: z.array(z.object({ id: z.string(), name: z.string() })),
+    });
+    const result = await callApiValidated('factory_create_strategies', CreateStrategiesResponseSchema, {
+        instanceId: state.instanceId,
+        productId: state.productId,
+        strategies,
+        interfaceContracts: strategyDesign.interfaceContracts.map((c) => {
+            const provider = idMap.get(c.provider);
+            if (!provider) {
+                throw new Error(`BUG: interface contract "${c.name}" provider tempId "${c.provider}" not found in idMap`);
+            }
+            const consumer = idMap.get(c.consumer);
+            if (!consumer) {
+                throw new Error(`BUG: interface contract "${c.name}" consumer tempId "${c.consumer}" not found in idMap`);
+            }
+            return { ...c, provider, consumer };
+        }),
+    });
+    console.log(`${LOG_PREFIX} Persisted ${result.strategies.length} strategies for instance ${state.instanceId}`);
+    // Return mappings
+    return strategyDesign.strategies.map((s) => ({
+        tempId: s.tempId,
+        strategyId: idMap.get(s.tempId),
+        name: s.name,
+    }));
+}
+/**
+ * Get strategies created by a factory instance (full data for planning).
+ */
+export async function getStrategiesByFactoryInstance(instanceId) {
+    const result = await callApiValidated('factory_get_instance_strategies', GetInstanceStrategiesResponseSchema, { instanceId });
+    return result.strategies;
+}
+// ============================================================================
+// Orchestrator: full designing phase
+// ============================================================================
+/**
+ * Run the full strategy design phase for a factory instance.
+ *
+ * Orchestrates: audit -> prompt -> generate -> validate -> persist -> transition.
+ * Called by runDesigning() in instance-lifecycle.ts.
+ *
+ * @returns An object indicating success or failure with an optional error message.
+ */
+export async function runStrategyDesignPhase(state, config, governor) {
+    const { instanceId, blueprint } = state;
+    const specification = state.specification;
+    console.log(`${LOG_PREFIX} Starting strategy design phase for instance ${instanceId}`);
+    // -- Guard: specification is required --
+    if (!specification || specification.trim().length === 0) {
+        const error = 'Instance has no specification -- cannot generate strategy design';
+        console.error(`${LOG_PREFIX} ${error}`);
+        return { success: false, error };
+    }
+    // -- Guard: worktree must exist --
+    // The designing phase expects the worktree to be created by the lifecycle manager.
+    // If not present, we cannot run Claude Code.
+    if (!state.worktreePath) {
+        const error = 'Instance has no worktree path -- cannot run strategy design';
+        console.error(`${LOG_PREFIX} ${error}`);
+        return { success: false, error };
+    }
+    // -- Step 1: Run codebase audit (best-effort) --
+    let auditReportText = null;
+    try {
+        const { runCodebaseAudit, formatAuditReport } = await import('./audit.js');
+        const auditReport = await runCodebaseAudit(state.worktreePath, specification, blueprint, config, governor);
+        if (auditReport) {
+            auditReportText = formatAuditReport(auditReport, blueprint);
+            console.log(`${LOG_PREFIX} Codebase audit completed: ` +
+                `${auditReport.existingImplementations.length} existing, ` +
+                `${auditReport.partialImplementations.length} partial, ` +
+                `${auditReport.gaps.length} gaps`);
+        }
+    }
+    catch (err) {
+        const auditError = err instanceof Error ? err.message : String(err);
+        console.warn(`${LOG_PREFIX} Codebase audit failed (non-fatal): ${auditError}`);
+        // Record audit failure on the instance so users have visibility
+        try {
+            const { updateInstanceStatus } = await import('./queries/instances.js');
+            await updateInstanceStatus(instanceId, state.status, {
+                escalationMessage: `Strategy design audit failed (non-fatal): ${auditError}. Proceeding without audit context.`,
+            });
+        }
+        catch (updateErr) {
+            console.warn(`${LOG_PREFIX} Failed to record audit failure on instance: ` +
+                `${updateErr instanceof Error ? updateErr.message : String(updateErr)}`);
+        }
+    }
+    // -- Step 2: Generate and validate strategy design (with retries) --
+    const originalPrompt = buildStrategyDesignPrompt(specification, blueprint, auditReportText, state.specType, state.reviewGaps);
+    let currentPrompt = originalPrompt;
+    let strategyDesign = null;
+    let lastError = '';
+    const allTokenUsages = [];
+    for (let attempt = 0; attempt <= MAX_STRATEGY_DESIGN_RETRIES; attempt++) {
+        if (attempt > 0) {
+            // Exponential backoff with jitter: base 2s, 4s, 8s... + random 0-1s jitter
+            const baseDelayMs = Math.min(2000 * Math.pow(2, attempt - 1), 30_000);
+            const jitterMs = Math.floor(Math.random() * 1000);
+            const delayMs = baseDelayMs + jitterMs;
+            console.log(`${LOG_PREFIX} Retry ${attempt}/${MAX_STRATEGY_DESIGN_RETRIES} after ${delayMs}ms backoff -- ` +
+                `previous error: ${lastError}`);
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+            currentPrompt = buildStrategyRetryPrompt(originalPrompt, lastError);
+        }
+        if (governor)
+            await governor.acquireSlot('factory');
+        let genResult;
+        try {
+            genResult = await generateAndValidateStrategyDesign(currentPrompt, config, state.worktreePath, state.blueprint);
+        }
+        finally {
+            if (governor)
+                governor.releaseSlot('factory');
+        }
+        allTokenUsages.push(genResult.tokenUsage);
+        if (genResult.success) {
+            strategyDesign = genResult.strategyDesign;
+            if (attempt > 0) {
+                console.log(`${LOG_PREFIX} Strategy design generation succeeded on retry ${attempt}`);
+            }
+            break;
+        }
+        lastError = genResult.error;
+        console.error(`${LOG_PREFIX} Strategy design attempt ${attempt + 1} failed: ${lastError}`);
+    }
+    const accumulatedTokenUsage = sumTokenUsage(allTokenUsages);
+    if (strategyDesign === null) {
+        const error = `Strategy design failed after ${MAX_STRATEGY_DESIGN_RETRIES + 1} attempt(s): ${lastError}`;
+        console.error(`${LOG_PREFIX} ${error}`);
+        return { success: false, error, tokenUsage: accumulatedTokenUsage };
+    }
+    // -- Step 3: Map and persist strategies --
+    let mappings;
+    try {
+        mappings = await mapAndPersistStrategies(state, strategyDesign);
+        console.log(`${LOG_PREFIX} Created ${mappings.length} strategy(ies) for instance ${instanceId}: ` +
+            mappings.map((m) => m.name).join(', '));
+    }
+    catch (err) {
+        const error = `Failed to persist strategies: ${err instanceof Error ? err.message : String(err)}`;
+        console.error(`${LOG_PREFIX} ${error}`);
+        return { success: false, error, tokenUsage: accumulatedTokenUsage };
+    }
+    // -- Step 4: Build dependency graph and validate contracts --
+    if (mappings.length > 1) {
+        try {
+            // Build graph from persisted strategy data
+            const graphNodes = strategyDesign.strategies.map((s) => {
+                const mapping = mappings.find((m) => m.tempId === s.tempId);
+                return {
+                    strategyId: mapping.strategyId,
+                    name: s.name,
+                    dependsOn: s.dependsOn.map((dep) => mappings.find((m) => m.tempId === dep).strategyId),
+                    interfaceContract: s.interfaceContract,
+                };
+            });
+            const graph = buildStrategyDependencyGraph(graphNodes);
+            console.log(`${LOG_PREFIX} Dependency graph: ${graph.executionOrder.length} nodes, ` +
+                `${graph.independentSubgraphs.length} independent subgraph(s)`);
+            // Validate interface contracts
+            const validation = validateInterfaceContracts(graph);
+            if (!validation.valid) {
+                const errorDetails = validation.errors
+                    .map((e) => e.reason)
+                    .join('; ');
+                console.error(`${LOG_PREFIX} Contract validation failed: ${errorDetails}`);
+                return { success: false, error: `Interface contract validation failed: ${errorDetails}`, tokenUsage: accumulatedTokenUsage };
+            }
+            if (validation.warnings.length > 0) {
+                for (const warning of validation.warnings) {
+                    console.warn(`${LOG_PREFIX} Contract warning: ${warning.message}`);
+                }
+            }
+        }
+        catch (err) {
+            const error = `Dependency graph validation failed: ${err instanceof Error ? err.message : String(err)}`;
+            console.error(`${LOG_PREFIX} ${error}`);
+            return { success: false, error, tokenUsage: accumulatedTokenUsage };
+        }
+    }
+    return { success: true, tokenUsage: accumulatedTokenUsage };
+}
+//# sourceMappingURL=strategy-design.js.map