opencode-orchestrator-plugin 1.0.0-beta.11 → 1.0.0-beta.12

package/dist/index.js

@@ -44,10 +44,13 @@ export const MyPlugin = async ({ directory, }) => {
     const configDetection = detectOrchestratorConfig();
     return {
         config: async (_config) => {
+            const commandDefaults = configDetection.orchestratorModel
+                ? { agent: "orchestrator", model: configDetection.orchestratorModel }
+                : { agent: "orchestrator" };
             _config.command = {
                 ..._config.command,
                 "orchestrator:implement": {
-                    agent: "orchestrator",
+                    ...commandDefaults,
                     template: asPrompt(ImplementPromptJson.prompt) + `
             Environment Details: 
               - Directory: ${directory}
@@ -60,17 +63,17 @@ export const MyPlugin = async ({ directory, }) => {
                     description: asDescription(ImplementPromptJson.description),
                 },
                 "orchestrator:newTrack": {
-                    agent: "orchestrator",
+                    ...commandDefaults,
                     template: asPrompt(NewTrackPromptJson.prompt),
                     description: asDescription(NewTrackPromptJson.description),
                 },
                 "orchestrator:revert": {
-                    agent: "orchestrator",
+                    ...commandDefaults,
                     template: asPrompt(RevertPromptJson.prompt),
                     description: asDescription(RevertPromptJson.description),
                 },
                 "orchestrator:setup": {
-                    agent: "orchestrator",
+                    ...commandDefaults,
                     template: asPrompt(SetupPromptJson.prompt) + `
             Environment Details: 
               - Directory: ${directory}
@@ -85,7 +88,7 @@ export const MyPlugin = async ({ directory, }) => {
                     description: asDescription(SetupPromptJson.description),
                 },
                 "orchestrator:status": {
-                    agent: "orchestrator",
+                    ...commandDefaults,
                     template: asPrompt(StatusPromptJson.prompt) + `
  
           

package/dist/tools/commands.test.js

@@ -18,13 +18,10 @@ describe("Command Tools", () => {
             sessionID: "test-session",
             messageID: "test-message",
         };
-        // Default mocks - must use triple quotes for the regex in commandFactory
-        vi.mocked(readFile).mockResolvedValue(`
-description = "Test command"
-prompt = """
-Test prompt content
-"""
-`);
+        vi.mocked(readFile).mockResolvedValue(JSON.stringify({
+            description: "Test command",
+            prompt: "Test prompt content"
+        }));
     });
     describe("createSetupTool", () => {
         it("should create a tool with correct description", () => {
@@ -32,10 +29,10 @@ Test prompt content
             expect(tool.description).toBe("Directives lookup tool for scaffolding the project and setting up the Orchestrator environment");
         });
         it("should return directives JSON string when executed", async () => {
-            vi.mocked(readFile).mockResolvedValue(`
-description = "Setup"
-prompt = """Setup Prompt"""
-`);
+            vi.mocked(readFile).mockResolvedValue(JSON.stringify({
+                description: "Setup",
+                prompt: "Setup Prompt"
+            }));
             const tool = createSetupTool(mockCtx);
             const result = await tool.execute({}, mockToolContext);
             expect(JSON.parse(result)).toEqual({ directives: "Setup Prompt" });
@@ -51,10 +48,10 @@ prompt = """Setup Prompt"""
             expect(tool.args).toHaveProperty("description");
         });
         it("should replace description in directives", async () => {
-            vi.mocked(readFile).mockResolvedValue(`
-description = "New Track"
-prompt = """Track description: {{args}}"""
-`);
+            vi.mocked(readFile).mockResolvedValue(JSON.stringify({
+                description: "New Track",
+                prompt: "Track description: {{args}}"
+            }));
             const tool = createNewTrackTool(mockCtx);
             const result = await tool.execute({ description: "Login feature" }, mockToolContext);
             expect(JSON.parse(result)).toEqual({ directives: "Track description: Login feature" });
@@ -70,10 +67,10 @@ prompt = """Track description: {{args}}"""
             expect(tool.args).toHaveProperty("track_name");
         });
         it("should replace track_name in directives", async () => {
-            vi.mocked(readFile).mockResolvedValue(`
-description = "Implement"
-prompt = """Track: {{track_name}}"""
-`);
+            vi.mocked(readFile).mockResolvedValue(JSON.stringify({
+                description: "Implement",
+                prompt: "Track: {{track_name}}"
+            }));
             const tool = createImplementTool(mockCtx);
             const result = await tool.execute({ track_name: "auth-track" }, mockToolContext);
             expect(JSON.parse(result)).toEqual({ directives: "Track: auth-track" });
@@ -83,10 +80,10 @@ prompt = """Track: {{track_name}}"""
                 if (typeof path === 'string' && path.endsWith("manual.md")) {
                     return "Manual Strategy";
                 }
-                return `
-description = "Implement"
-prompt = """Strategy: {{strategy_section}}"""
-`;
+                return JSON.stringify({
+                    description: "Implement",
+                    prompt: "Strategy: {{strategy_section}}"
+                });
             });
             const tool = createImplementTool(mockCtx);
             const result = await tool.execute({}, mockToolContext);
@@ -99,10 +96,10 @@ prompt = """Strategy: {{strategy_section}}"""
             expect(tool.description).toBe("Directives lookup tool for displaying the current progress of the project");
         });
         it("should execute and return directives", async () => {
-            vi.mocked(readFile).mockResolvedValue(`
-description = "Status"
-prompt = """Status Prompt"""
-`);
+            vi.mocked(readFile).mockResolvedValue(JSON.stringify({
+                description: "Status",
+                prompt: "Status Prompt"
+            }));
             const tool = createStatusTool(mockCtx);
             const result = await tool.execute({}, mockToolContext);
             expect(JSON.parse(result)).toEqual({ directives: "Status Prompt" });
@@ -114,10 +111,10 @@ prompt = """Status Prompt"""
             expect(tool.description).toBe("Directives lookup tool for reverting previous work");
         });
         it("should replace target in directives", async () => {
-            vi.mocked(readFile).mockResolvedValue(`
-description = "Revert"
-prompt = """Target: {{target}}"""
-`);
+            vi.mocked(readFile).mockResolvedValue(JSON.stringify({
+                description: "Revert",
+                prompt: "Target: {{target}}"
+            }));
             const tool = createRevertTool(mockCtx);
             const result = await tool.execute({ target: "track 1" }, mockToolContext);
             expect(JSON.parse(result)).toEqual({ directives: "Target: track 1" });
@@ -133,10 +130,10 @@ prompt = """Target: {{target}}"""
     });
     describe("Prompt Replacement", () => {
         it("should replace standard variables in directives", async () => {
-            vi.mocked(readFile).mockResolvedValue(`
-description = "Test"
-prompt = """Templates: {{templatesDir}}"""
-`);
+            vi.mocked(readFile).mockResolvedValue(JSON.stringify({
+                description: "Test",
+                prompt: "Templates: {{templatesDir}}"
+            }));
             const tool = createNewTrackTool(mockCtx);
             const result = await tool.execute({}, mockToolContext);
             expect(JSON.parse(result).directives).toContain("Templates:");

package/dist/utils/autogenerateFlow.d.ts

@@ -1,7 +1,9 @@
 import { ProjectContext } from './contextAnalysis.js';
 export type SectionType = 'product_guide' | 'product_guidelines' | 'tech_stack' | 'workflow';
 export type UserChoice = 'A' | 'B' | 'C';
+export type FallbackChoice = 'A' | 'B' | 'C';
 export type FlowStatus = 'generating' | 'presented' | 'accepted' | 'edited' | 'regenerating';
+export type FallbackAction = 'manual' | 'regenerate' | 'accept_partial';
 export interface AutogenerationState {
     questionId: string;
     attemptNumber: number;
@@ -17,15 +19,38 @@ export interface FlowResult {
     content?: string;
     error?: string;
     state?: AutogenerationState;
+    failureSummary?: string;
+    fallbackPrompt?: string;
+    fallbackAction?: FallbackAction;
+    fallbackState?: ContextSufficiencyResult;
+    ambiguityState?: AmbiguityResult;
 }
 export interface ValidationResult {
     valid: boolean;
     error?: string;
 }
+export interface ContextSufficiencyResult {
+    sufficient: boolean;
+    reason: string;
+    missing: string[];
+}
+export interface AmbiguityResult {
+    ambiguous: boolean;
+    reason: string;
+    signals: string[];
+}
 export declare const MAX_REGENERATION_ATTEMPTS = 3;
+export declare const MIN_CONTEXT_SIGNALS = 2;
+export declare const MIN_CONFIDENCE_THRESHOLD = 0.4;
 export declare function createInitialState(questionId: string): AutogenerationState;
 export declare function generateContentForSection(sectionType: SectionType, context: ProjectContext): FlowResult;
 export declare function validateContent(content: string, sectionType: SectionType): ValidationResult;
+export declare function evaluateContextSufficiency(context: ProjectContext): ContextSufficiencyResult;
+export declare function formatAutogenerationFailure(sectionType: SectionType, error: string, sufficiency: ContextSufficiencyResult, ambiguity: AmbiguityResult): string;
+export declare function evaluateAmbiguity(context: ProjectContext): AmbiguityResult;
+export declare function formatFallbackPrompt(reason: string, missing: string[]): string;
+export declare function parseFallbackChoice(input: string): FallbackChoice | null;
+export declare function resolveFallbackAction(choice: FallbackChoice | null): FallbackAction;
 export declare function handleAccept(state: AutogenerationState, sectionType: SectionType): FlowResult;
 export declare function handleEdit(state: AutogenerationState, editedContent: string, sectionType: SectionType): FlowResult;
 export declare function handleRegenerate(state: AutogenerationState, guidance: string, sectionType: SectionType, context: ProjectContext): FlowResult;
@@ -35,3 +60,6 @@ export declare function formatRegeneratePrompt(): string;
 export declare function formatMaxAttemptsPrompt(): string;
 export declare function parseUserChoice(input: string): UserChoice | null;
 export declare function isCancel(input: string): boolean;
+export declare function handleFallbackManual(sectionType: SectionType, reason: string): FlowResult;
+export declare function handleFallbackAcceptPartial(partialContent: string, sectionType: SectionType, reason: string): FlowResult;
+export declare function handleFallbackRegenerate(sectionType: SectionType, context: ProjectContext, additionalContext: string): FlowResult;

package/dist/utils/autogenerateFlow.js

@@ -1,5 +1,7 @@
 import { generateProductGuide, generateProductGuidelines, generateTechStack, generateWorkflow, } from './contentGeneration.js';
 export const MAX_REGENERATION_ATTEMPTS = 3;
+export const MIN_CONTEXT_SIGNALS = 2;
+export const MIN_CONFIDENCE_THRESHOLD = 0.4;
 export function createInitialState(questionId) {
     return {
         questionId,
@@ -31,10 +33,20 @@ export function generateContentForSection(sectionType, context) {
             default:
                 return { success: false, error: `Unknown section type: ${sectionType}` };
         }
-        if (generationResult.confidence < 0.4) {
+        if (generationResult.confidence < MIN_CONFIDENCE_THRESHOLD) {
+            const sufficiency = evaluateContextSufficiency(context);
+            const ambiguity = evaluateAmbiguity(context);
+            const error = 'Insufficient context for reliable autogeneration';
+            const failureSummary = formatAutogenerationFailure(sectionType, error, sufficiency, ambiguity);
+            const fallbackPrompt = formatFallbackPrompt(error, sufficiency.missing);
             return {
                 success: false,
-                error: 'Insufficient context for reliable autogeneration',
+                error,
+                failureSummary,
+                fallbackPrompt,
+                fallbackAction: resolveFallbackAction(null),
+                fallbackState: sufficiency,
+                ambiguityState: ambiguity,
             };
         }
         return {
@@ -43,9 +55,19 @@ export function generateContentForSection(sectionType, context) {
         };
     }
     catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error during generation';
+        const sufficiency = evaluateContextSufficiency(context);
+        const ambiguity = evaluateAmbiguity(context);
+        const failureSummary = formatAutogenerationFailure(sectionType, message, sufficiency, ambiguity);
+        const fallbackPrompt = formatFallbackPrompt(message, sufficiency.missing);
         return {
             success: false,
-            error: error instanceof Error ? error.message : 'Unknown error during generation',
+            error: message,
+            failureSummary,
+            fallbackPrompt,
+            fallbackAction: resolveFallbackAction(null),
+            fallbackState: sufficiency,
+            ambiguityState: ambiguity,
         };
     }
 }
@@ -77,6 +99,132 @@ export function validateContent(content, sectionType) {
     }
     return { valid: true };
 }
+export function evaluateContextSufficiency(context) {
+    const missing = [];
+    const signals = [];
+    const hasManifests = context.raw.manifests.length > 0;
+    const hasDocs = context.raw.docs.length > 0;
+    const hasGit = context.raw.git.commitCount > 0;
+    const hasStructure = context.raw.structure.structure.length > 0;
+    const hasIgnores = context.raw.ignores.patterns.length > 0;
+    const hasCicd = context.raw.cicd.length > 0;
+    if (!hasManifests)
+        missing.push('manifest files');
+    if (!hasDocs)
+        missing.push('documentation');
+    if (!hasGit)
+        missing.push('git history');
+    if (!hasStructure)
+        missing.push('source structure');
+    if (!hasIgnores)
+        missing.push('ignore patterns');
+    if (!hasCicd)
+        missing.push('CI/CD configuration');
+    if (hasManifests)
+        signals.push('manifests');
+    if (hasDocs)
+        signals.push('docs');
+    if (hasGit)
+        signals.push('git');
+    if (hasStructure)
+        signals.push('structure');
+    if (hasIgnores)
+        signals.push('ignores');
+    if (hasCicd)
+        signals.push('cicd');
+    if (signals.length >= MIN_CONTEXT_SIGNALS) {
+        return {
+            sufficient: true,
+            reason: `Detected ${signals.length} context sources: ${signals.join(', ')}`,
+            missing,
+        };
+    }
+    return {
+        sufficient: false,
+        reason: 'Not enough project context sources to autogenerate reliably',
+        missing,
+    };
+}
+export function formatAutogenerationFailure(sectionType, error, sufficiency, ambiguity) {
+    const missingList = sufficiency.missing.length > 0
+        ? `Missing: ${sufficiency.missing.join(', ')}`
+        : 'Missing: none detected';
+    const ambiguityList = ambiguity.signals.length > 0
+        ? `Ambiguity signals: ${ambiguity.signals.join('; ')}`
+        : 'Ambiguity signals: none';
+    return `Autogeneration failed for ${sectionType}.
+Reason: ${error}
+${sufficiency.reason}
+${missingList}
+${ambiguityList}`;
+}
+export function evaluateAmbiguity(context) {
+    const signals = [];
+    const warnings = context.meta.warnings;
+    if (warnings.some((warning) => warning.toLowerCase().includes('no manifest'))) {
+        signals.push('Missing manifest files');
+    }
+    if (warnings.some((warning) => warning.toLowerCase().includes('no readme'))) {
+        signals.push('Missing README documentation');
+    }
+    if (context.insights.projectType === 'unknown') {
+        signals.push('Unknown project type');
+    }
+    if (context.insights.techStack.languages.length === 0) {
+        signals.push('No dominant language detected');
+    }
+    if (context.meta.filesAnalyzed === 0) {
+        signals.push('No files analyzed');
+    }
+    if (signals.length === 0) {
+        return { ambiguous: false, reason: 'Context appears coherent', signals };
+    }
+    return {
+        ambiguous: true,
+        reason: 'Project context appears ambiguous or incomplete',
+        signals,
+    };
+}
+export function formatFallbackPrompt(reason, missing) {
+    const missingList = missing.length > 0
+        ? `Missing: ${missing.join(', ')}`
+        : 'No specific missing data identified.';
+    return `Autogeneration could not proceed. ${reason}
+
+${missingList}
+
+Please choose how to continue:
+A) Continue with manual Q&A
+B) Provide more context for regeneration
+C) Accept partial results (use what was generated)
+
+Please enter A, B, or C:`;
+}
+export function parseFallbackChoice(input) {
+    const normalized = input.trim().toUpperCase();
+    if (['A', 'MANUAL', 'M'].includes(normalized)) {
+        return 'A';
+    }
+    if (['B', 'CONTEXT', 'REGENERATE', 'R'].includes(normalized)) {
+        return 'B';
+    }
+    if (['C', 'PARTIAL', 'ACCEPT'].includes(normalized)) {
+        return 'C';
+    }
+    return null;
+}
+export function resolveFallbackAction(choice) {
+    switch (choice) {
+        case 'A':
+            return 'manual';
+        case 'B':
+            return 'regenerate';
+        case 'C':
+            return 'accept_partial';
+        default:
+            return 'manual';
+    }
+}
 export function handleAccept(state, sectionType) {
     const validation = validateContent(state.content, sectionType);
     if (!validation.valid) {
@@ -216,3 +364,28 @@ export function parseUserChoice(input) {
 export function isCancel(input) {
     return input.trim().toLowerCase() === 'cancel';
 }
+export function handleFallbackManual(sectionType, reason) {
+    return {
+        success: false,
+        error: `Fallback to manual Q&A: ${reason}`,
+        fallbackAction: 'manual',
+    };
+}
+export function handleFallbackAcceptPartial(partialContent, sectionType, reason) {
+    const validation = validateContent(partialContent, sectionType);
+    if (!validation.valid) {
+        return {
+            success: false,
+            error: `Partial content is invalid: ${validation.error}. Falling back to manual Q&A.`,
+            fallbackAction: 'manual',
+        };
+    }
+    return {
+        success: true,
+        content: partialContent,
+        fallbackAction: 'accept_partial',
+    };
+}
+export function handleFallbackRegenerate(sectionType, context, additionalContext) {
+    return generateContentForSection(sectionType, context);
+}

package/dist/utils/autogenerateFlow.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { createInitialState, generateContentForSection, validateContent, handleAccept, handleEdit, handleRegenerate, formatPresentationPrompt, formatEditPrompt, formatRegeneratePrompt, formatMaxAttemptsPrompt, parseUserChoice, isCancel, MAX_REGENERATION_ATTEMPTS, } from './autogenerateFlow.js';
+import { createInitialState, generateContentForSection, validateContent, handleAccept, handleEdit, handleRegenerate, formatPresentationPrompt, formatEditPrompt, formatRegeneratePrompt, formatMaxAttemptsPrompt, parseUserChoice, isCancel, MAX_REGENERATION_ATTEMPTS, MIN_CONTEXT_SIGNALS, evaluateContextSufficiency, evaluateAmbiguity, formatFallbackPrompt, formatAutogenerationFailure, parseFallbackChoice, resolveFallbackAction, handleFallbackManual, handleFallbackAcceptPartial, handleFallbackRegenerate, } from './autogenerateFlow.js';
 describe('autogenerateFlow', () => {
     let mockContext;
     let initialState;
@@ -87,6 +87,47 @@ describe('autogenerateFlow', () => {
             expect(result.content).toBeTruthy();
             expect(result.error).toBeUndefined();
         });
+        it('should report failure when confidence below threshold', () => {
+            const lowConfidenceContext = {
+                ...mockContext,
+                insights: {
+                    ...mockContext.insights,
+                    techStack: {
+                        ...mockContext.insights.techStack,
+                        frameworks: [],
+                        testing: [],
+                    },
+                    workflow: {
+                        ...mockContext.insights.workflow,
+                        testingStrategy: 'unknown',
+                        commitConvention: 'none',
+                    },
+                },
+                raw: {
+                    ...mockContext.raw,
+                    docs: [],
+                    cicd: [],
+                    manifests: [],
+                    git: {
+                        commitCount: 0,
+                        conventionalCommits: 0,
+                        patterns: [],
+                        warnings: [],
+                    },
+                    structure: {
+                        structure: [],
+                        fileExtensions: [],
+                        warnings: [],
+                    },
+                },
+            };
+            const result = generateContentForSection('workflow', lowConfidenceContext);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('Insufficient context');
+            expect(result.failureSummary).toContain('Autogeneration failed');
+            expect(result.fallbackPrompt).toContain('Continue with manual Q&A');
+            expect(result.fallbackState?.sufficient).toBe(false);
+        });
         it('should generate content for product_guidelines section', () => {
             const result = generateContentForSection('product_guidelines', mockContext);
             expect(result.success).toBe(true);
@@ -103,7 +144,7 @@ describe('autogenerateFlow', () => {
             expect(result.success).toBe(true);
             expect(result.content).toBeTruthy();
         });
-        it('should succeed even with low confidence context (confidence checked at presentation)', () => {
+        it('should reject low confidence context during generation', () => {
             const lowConfidenceContext = {
                 ...mockContext,
                 insights: {
@@ -116,11 +157,35 @@ describe('autogenerateFlow', () => {
                         ...mockContext.insights.workflow,
                         confidence: 0.3,
                     },
+                    techStack: {
+                        ...mockContext.insights.techStack,
+                        frameworks: [],
+                        languages: [],
+                    },
+                },
+                raw: {
+                    ...mockContext.raw,
+                    docs: [],
+                    cicd: [],
+                    manifests: [],
+                    git: {
+                        commitCount: 0,
+                        conventionalCommits: 0,
+                        patterns: [],
+                        warnings: [],
+                    },
+                    structure: {
+                        structure: [],
+                        fileExtensions: [],
+                        warnings: [],
+                    },
                 },
             };
             const result = generateContentForSection('product_guide', lowConfidenceContext);
-            expect(result.success).toBe(true);
-            expect(result.content).toBeTruthy();
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('Insufficient context');
+            expect(result.fallbackPrompt).toContain('Provide more context');
+            expect(result.ambiguityState?.ambiguous).toBe(true);
         });
     });
     describe('validateContent', () => {
@@ -289,6 +354,120 @@ describe('autogenerateFlow', () => {
             expect(prompt).toContain('C) Switch to manual Q&A');
         });
     });
+    describe('evaluateContextSufficiency', () => {
+        it('should report sufficient context with multiple signals', () => {
+            const result = evaluateContextSufficiency(mockContext);
+            expect(result.sufficient).toBe(true);
+            expect(result.reason).toContain('context sources');
+            expect(result.missing.length).toBeLessThan(6);
+        });
+        it('should report insufficient context with minimal signals', () => {
+            const minimalContext = {
+                ...mockContext,
+                raw: {
+                    ...mockContext.raw,
+                    manifests: [],
+                    docs: [],
+                    git: { ...mockContext.raw.git, commitCount: 0 },
+                    structure: { ...mockContext.raw.structure, structure: [] },
+                    ignores: { patterns: [] },
+                    cicd: [],
+                },
+                meta: {
+                    ...mockContext.meta,
+                    warnings: [
+                        'No manifest files found',
+                        'No README found',
+                        'Not a git repository',
+                    ],
+                },
+            };
+            const result = evaluateContextSufficiency(minimalContext);
+            expect(result.sufficient).toBe(false);
+            expect(result.reason).toContain('Not enough project context');
+            expect(result.missing.length).toBeGreaterThanOrEqual(MIN_CONTEXT_SIGNALS);
+        });
+    });
+    describe('evaluateAmbiguity', () => {
+        it('should detect ambiguous contexts', () => {
+            const ambiguousContext = {
+                ...mockContext,
+                insights: {
+                    ...mockContext.insights,
+                    projectType: 'unknown',
+                    techStack: { ...mockContext.insights.techStack, languages: [] },
+                },
+                meta: {
+                    ...mockContext.meta,
+                    filesAnalyzed: 0,
+                    warnings: ['No manifest files found', 'No README found'],
+                },
+            };
+            const result = evaluateAmbiguity(ambiguousContext);
+            expect(result.ambiguous).toBe(true);
+            expect(result.signals.length).toBeGreaterThan(0);
+        });
+    });
+    describe('formatFallbackPrompt', () => {
+        it('should include reason and missing data', () => {
+            const prompt = formatFallbackPrompt('Insufficient context', ['manifests']);
+            expect(prompt).toContain('Insufficient context');
+            expect(prompt).toContain('Missing: manifests');
+            expect(prompt).toContain('A) Continue with manual Q&A');
+        });
+    });
+    describe('formatAutogenerationFailure', () => {
+        it('should format a detailed failure summary', () => {
+            const sufficiency = {
+                sufficient: false,
+                reason: 'Not enough project context sources',
+                missing: ['docs'],
+            };
+            const ambiguity = {
+                ambiguous: true,
+                reason: 'Context ambiguous',
+                signals: ['Missing README'],
+            };
+            const message = formatAutogenerationFailure('product_guide', 'Insufficient context', sufficiency, ambiguity);
+            expect(message).toContain('Autogeneration failed');
+            expect(message).toContain('Insufficient context');
+            expect(message).toContain('Missing: docs');
+            expect(message).toContain('Ambiguity signals');
+        });
+    });
+    describe('parseFallbackChoice', () => {
+        it('should parse manual choice', () => {
+            expect(parseFallbackChoice('A')).toBe('A');
+            expect(parseFallbackChoice('manual')).toBe('A');
+            expect(parseFallbackChoice('m')).toBe('A');
+        });
+        it('should parse regenerate choice', () => {
+            expect(parseFallbackChoice('B')).toBe('B');
+            expect(parseFallbackChoice('regenerate')).toBe('B');
+            expect(parseFallbackChoice('context')).toBe('B');
+        });
+        it('should parse accept partial choice', () => {
+            expect(parseFallbackChoice('C')).toBe('C');
+            expect(parseFallbackChoice('partial')).toBe('C');
+            expect(parseFallbackChoice('accept')).toBe('C');
+        });
+        it('should reject invalid fallback choices', () => {
+            expect(parseFallbackChoice('D')).toBeNull();
+            expect(parseFallbackChoice('')).toBeNull();
+        });
+    });
+    describe('resolveFallbackAction', () => {
+        it('should resolve manual action', () => {
+            expect(resolveFallbackAction('A')).toBe('manual');
+            expect(resolveFallbackAction(null)).toBe('manual');
+        });
+        it('should resolve regenerate action', () => {
+            expect(resolveFallbackAction('B')).toBe('regenerate');
+        });
+        it('should resolve accept partial action', () => {
+            expect(resolveFallbackAction('C')).toBe('accept_partial');
+        });
+    });
     describe('parseUserChoice', () => {
         it('should parse Accept choices', () => {
             expect(parseUserChoice('A')).toBe('A');
@@ -334,4 +513,98 @@ describe('autogenerateFlow', () => {
             expect(isCancel('')).toBe(false);
         });
     });
+    describe('Fallback Handlers', () => {
+        describe('handleFallbackManual', () => {
+            it('should return failure with manual fallback action', () => {
+                const result = handleFallbackManual('product_guide', 'Insufficient context');
+                expect(result.success).toBe(false);
+                expect(result.error).toContain('Fallback to manual Q&A');
+                expect(result.error).toContain('Insufficient context');
+                expect(result.fallbackAction).toBe('manual');
+            });
+        });
+        describe('handleFallbackAcceptPartial', () => {
+            it('should accept valid partial content', () => {
+                const partialContent = 'This is a partial product description with limited details';
+                const result = handleFallbackAcceptPartial(partialContent, 'product_guide', 'Low confidence generation');
+                expect(result.success).toBe(true);
+                expect(result.content).toBe(partialContent);
+                expect(result.fallbackAction).toBe('accept_partial');
+            });
+            it('should reject invalid partial content and fall back to manual', () => {
+                const invalidContent = 'xyz';
+                const result = handleFallbackAcceptPartial(invalidContent, 'product_guide', 'Low confidence');
+                expect(result.success).toBe(false);
+                expect(result.error).toContain('Partial content is invalid');
+                expect(result.fallbackAction).toBe('manual');
+            });
+            it('should reject empty partial content', () => {
+                const result = handleFallbackAcceptPartial('', 'product_guide', 'Empty generation');
+                expect(result.success).toBe(false);
+                expect(result.error).toContain('Partial content is invalid');
+                expect(result.fallbackAction).toBe('manual');
+            });
+        });
+        describe('handleFallbackRegenerate', () => {
+            it('should regenerate content with updated context', () => {
+                const result = handleFallbackRegenerate('product_guide', mockContext, 'Focus on developer tooling aspect');
+                expect(result.success).toBe(true);
+                expect(result.content).toBeTruthy();
+            });
+            it('should fail regeneration with insufficient context', () => {
+                const minimalContext = {
+                    raw: {
+                        manifests: [],
+                        docs: [],
+                        cicd: [],
+                        ignores: { patterns: [] },
+                        git: {
+                            commitCount: 0,
+                            conventionalCommits: 0,
+                            patterns: [],
+                            warnings: [],
+                        },
+                        structure: {
+                            structure: [],
+                            fileExtensions: [],
+                            warnings: [],
+                        },
+                    },
+                    insights: {
+                        techStack: {
+                            languages: [],
+                            frameworks: [],
+                            databases: [],
+                            infrastructure: [],
+                            testing: [],
+                        },
+                        product: {
+                            targetUsers: [],
+                            coreProblems: [],
+                            keyFeatures: [],
+                            confidence: 0.0,
+                        },
+                        workflow: {
+                            commitConvention: 'none',
+                            testingStrategy: 'unknown',
+                            branchStrategy: 'unknown',
+                            confidence: 0.0,
+                        },
+                        projectType: 'unknown',
+                        maturity: 'early',
+                    },
+                    meta: {
+                        analyzedAt: new Date().toISOString(),
+                        analysisTimeMs: 0,
+                        filesAnalyzed: 0,
+                        categoriesCompleted: [],
+                        warnings: [],
+                    },
+                };
+                const result = handleFallbackRegenerate('workflow', minimalContext, 'Please add more workflow details');
+                expect(result.success).toBe(false);
+                expect(result.error).toContain('Insufficient context');
+            });
+        });
+    });
 });

package/dist/utils/configDetection.d.ts

@@ -2,5 +2,6 @@ export interface ConfigDetectionResult {
     hasOrchestratorInOpenCode: boolean;
     hasOrchestratorInOMO: boolean;
     synergyActive: boolean;
+    orchestratorModel?: string;
 }
 export declare function detectOrchestratorConfig(): ConfigDetectionResult;

package/dist/utils/configDetection.js

@@ -7,29 +7,43 @@ export function detectOrchestratorConfig() {
     const omoJsonPath = join(opencodeConfigDir, "oh-my-opencode.json");
     let hasOrchestratorInOpenCode = false;
     let hasOrchestratorInOMO = false;
-    if (existsSync(opencodeJsonPath)) {
+    let orchestratorModel;
+    // Check oh-my-opencode.json first (higher priority)
+    if (existsSync(omoJsonPath)) {
         try {
-            const config = JSON.parse(readFileSync(opencodeJsonPath, "utf-8"));
-            if (config.agent && config.agent.orchestrator) {
-                hasOrchestratorInOpenCode = true;
+            const config = JSON.parse(readFileSync(omoJsonPath, "utf-8"));
+            if (config.agents && config.agents.orchestrator) {
+                hasOrchestratorInOMO = true;
+                // Extract model from oh-my-opencode.json
+                if (config.agents.orchestrator.model) {
+                    orchestratorModel = config.agents.orchestrator.model;
+                }
             }
         }
         catch (e) {
+            // Silently fail on parse errors
         }
     }
-    if (existsSync(omoJsonPath)) {
+    // Check opencode.json (fallback if model not found in OMO)
+    if (existsSync(opencodeJsonPath)) {
         try {
-            const config = JSON.parse(readFileSync(omoJsonPath, "utf-8"));
-            if (config.agents && config.agents.orchestrator) {
-                hasOrchestratorInOMO = true;
+            const config = JSON.parse(readFileSync(opencodeJsonPath, "utf-8"));
+            if (config.agent && config.agent.orchestrator) {
+                hasOrchestratorInOpenCode = true;
+                // Only use this model if we didn't find one in oh-my-opencode.json
+                if (!orchestratorModel && config.agent.orchestrator.model) {
+                    orchestratorModel = config.agent.orchestrator.model;
+                }
             }
         }
         catch (e) {
+            // Silently fail on parse errors
         }
     }
     return {
         hasOrchestratorInOpenCode,
         hasOrchestratorInOMO,
         synergyActive: hasOrchestratorInOMO,
+        orchestratorModel,
     };
 }

package/dist/utils/configDetection.test.js

@@ -18,7 +18,7 @@ describe("configDetection", () => {
         vi.mocked(existsSync).mockImplementation((path) => path === opencodeJsonPath);
         vi.mocked(readFileSync).mockImplementation((path) => {
             if (path === opencodeJsonPath) {
-                return JSON.stringify({ agent: { orchestrator: {} } });
+                return JSON.stringify({ agent: { orchestrator: { model: "anthropic/claude-3-5-sonnet" } } });
             }
             return "";
         });
@@ -26,12 +26,13 @@ describe("configDetection", () => {
         expect(result.hasOrchestratorInOpenCode).toBe(true);
         expect(result.hasOrchestratorInOMO).toBe(false);
         expect(result.synergyActive).toBe(false);
+        expect(result.orchestratorModel).toBe("anthropic/claude-3-5-sonnet");
     });
     it("should detect orchestrator in oh-my-opencode.json and activate synergy", () => {
         vi.mocked(existsSync).mockImplementation((path) => path === omoJsonPath);
         vi.mocked(readFileSync).mockImplementation((path) => {
             if (path === omoJsonPath) {
-                return JSON.stringify({ agents: { orchestrator: {} } });
+                return JSON.stringify({ agents: { orchestrator: { model: "anthropic/claude-3-5-haiku" } } });
             }
             return "";
         });
@@ -39,15 +40,16 @@ describe("configDetection", () => {
         expect(result.hasOrchestratorInOpenCode).toBe(false);
         expect(result.hasOrchestratorInOMO).toBe(true);
         expect(result.synergyActive).toBe(true);
+        expect(result.orchestratorModel).toBe("anthropic/claude-3-5-haiku");
     });
     it("should handle both configs present", () => {
         vi.mocked(existsSync).mockReturnValue(true);
         vi.mocked(readFileSync).mockImplementation((path) => {
             if (path === opencodeJsonPath) {
-                return JSON.stringify({ agent: { orchestrator: {} } });
+                return JSON.stringify({ agent: { orchestrator: { model: "anthropic/claude-3-5-sonnet" } } });
             }
             if (path === omoJsonPath) {
-                return JSON.stringify({ agents: { orchestrator: {} } });
+                return JSON.stringify({ agents: { orchestrator: { model: "anthropic/claude-3-5-haiku" } } });
             }
             return "";
         });
@@ -55,6 +57,7 @@ describe("configDetection", () => {
         expect(result.hasOrchestratorInOpenCode).toBe(true);
         expect(result.hasOrchestratorInOMO).toBe(true);
         expect(result.synergyActive).toBe(true);
+        expect(result.orchestratorModel).toBe("anthropic/claude-3-5-haiku");
     });
     it("should handle missing configs", () => {
         vi.mocked(existsSync).mockReturnValue(false);
@@ -62,6 +65,7 @@ describe("configDetection", () => {
         expect(result.hasOrchestratorInOpenCode).toBe(false);
         expect(result.hasOrchestratorInOMO).toBe(false);
         expect(result.synergyActive).toBe(false);
+        expect(result.orchestratorModel).toBeUndefined();
     });
     it("should handle malformed JSON", () => {
         vi.mocked(existsSync).mockReturnValue(true);
@@ -70,5 +74,46 @@ describe("configDetection", () => {
         expect(result.hasOrchestratorInOpenCode).toBe(false);
         expect(result.hasOrchestratorInOMO).toBe(false);
         expect(result.synergyActive).toBe(false);
+        expect(result.orchestratorModel).toBeUndefined();
+    });
+    it("should prioritize oh-my-opencode.json model over opencode.json", () => {
+        vi.mocked(existsSync).mockReturnValue(true);
+        vi.mocked(readFileSync).mockImplementation((path) => {
+            if (path === opencodeJsonPath) {
+                return JSON.stringify({ agent: { orchestrator: { model: "model-from-opencode" } } });
+            }
+            if (path === omoJsonPath) {
+                return JSON.stringify({ agents: { orchestrator: { model: "model-from-omo" } } });
+            }
+            return "";
+        });
+        const result = detectOrchestratorConfig();
+        expect(result.orchestratorModel).toBe("model-from-omo");
+    });
+    it("should fallback to opencode.json model when oh-my-opencode.json has no model", () => {
+        vi.mocked(existsSync).mockReturnValue(true);
+        vi.mocked(readFileSync).mockImplementation((path) => {
+            if (path === opencodeJsonPath) {
+                return JSON.stringify({ agent: { orchestrator: { model: "model-from-opencode" } } });
+            }
+            if (path === omoJsonPath) {
+                return JSON.stringify({ agents: { orchestrator: {} } });
+            }
+            return "";
+        });
+        const result = detectOrchestratorConfig();
+        expect(result.orchestratorModel).toBe("model-from-opencode");
+    });
+    it("should handle orchestrator config without model field", () => {
+        vi.mocked(existsSync).mockImplementation((path) => path === omoJsonPath);
+        vi.mocked(readFileSync).mockImplementation((path) => {
+            if (path === omoJsonPath) {
+                return JSON.stringify({ agents: { orchestrator: {} } });
+            }
+            return "";
+        });
+        const result = detectOrchestratorConfig();
+        expect(result.hasOrchestratorInOMO).toBe(true);
+        expect(result.orchestratorModel).toBeUndefined();
     });
 });

package/dist/utils/contextAnalysis.test.js

@@ -124,12 +124,12 @@ import { foo } from 'test-project'
             expect(result.docs[0].content).toContain("Feature A");
         });
         it("should sample large files (> 10KB)", async () => {
-            const largeContent = "x".repeat(15000) + "\n\nIMPORTANT INFO";
+            const largeLine = "x".repeat(100);
+            const largeContent = Array(250).fill(largeLine).join("\n") + "\n\nIMPORTANT INFO";
             vi.mocked(readFile).mockResolvedValue(largeContent);
             vi.mocked(readdir).mockResolvedValue(["README.md"]);
             const result = await analyzeDocs("/test/project");
             expect(result.docs).toHaveLength(1);
-            // Should sample, not include entire content
             expect(result.docs[0].content.length).toBeLessThan(largeContent.length);
             expect(result.warnings).toContain("Large file detected, using sampling");
         });
@@ -142,25 +142,23 @@ import { foo } from 'test-project'
     });
     describe("analyzeGitHistory", () => {
         it("should analyze git commit patterns", async () => {
-            vi.mocked(execSync).mockReturnValue(Buffer.from(`
-feat: add new feature
-fix: bug fix
-chore: update deps
-test: add tests
-feat(auth): implement login
-`));
+            vi.mocked(execSync).mockImplementation(() => `abc1234 feat: add new feature
+def5678 fix: bug fix
+abc9101 chore: update deps
+def1121 test: add tests
+abc3141 feat(auth): implement login
+`);
             const result = await analyzeGitHistory("/test/project");
             expect(result.commitCount).toBe(5);
             expect(result.conventionalCommits).toBeGreaterThan(0);
             expect(result.patterns).toContain("conventional");
         });
         it("should detect non-conventional commit patterns", async () => {
-            vi.mocked(execSync).mockReturnValue(Buffer.from(`
-Add new feature
-Fix bug
-Update README
-Random commit message
-`));
+            vi.mocked(execSync).mockImplementation(() => `abc1234 Add new feature
+def5678 Fix bug
+abc9101 Update README
+def1121 Random commit message
+`);
             const result = await analyzeGitHistory("/test/project");
             expect(result.commitCount).toBe(4);
             expect(result.conventionalCommits).toBe(0);
@@ -179,10 +177,10 @@ Random commit message
         it("should analyze directory structure", async () => {
             vi.mocked(readdir).mockImplementation(async (path) => {
                 if (path === "/test/project") {
-                    return ["src", "tests", "package.json", "README.md"];
+                    return ["src", "tests", "package.json", "README.md", "index.ts", "config.ts"];
                 }
                 if (path === "/test/project/src") {
-                    return ["index.ts", "utils.ts", "components"];
+                    return ["utils.ts", "components"];
                 }
                 return [];
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-orchestrator-plugin",
-  "version": "1.0.0-beta.11",
+  "version": "1.0.0-beta.12",
   "description": "Orchestrator plugin for OpenCode",
   "type": "module",
   "repository": {