@reinamaccredy/oh-my-opencode 3.0.0-beta.8 → 3.0.0

package/dist/features/background-agent/index.d.ts

@@ -1,3 +1,3 @@
 export * from "./types";
-export { BackgroundManager } from "./manager";
+export { BackgroundManager, type PendingNotification } from "./manager";
 export { ConcurrencyManager } from "./concurrency";

package/dist/features/background-agent/manager.d.ts

@@ -12,9 +12,17 @@ interface Event {
     type: string;
     properties?: EventProperties;
 }
+export interface PendingNotification {
+    taskId: string;
+    description: string;
+    duration: string;
+    status: "completed" | "error";
+    error?: string;
+}
 export declare class BackgroundManager {
     private tasks;
     private notifications;
+    private pendingNotifications;
     private client;
     private directory;
     private pollingInterval?;
@@ -43,6 +51,8 @@ export declare class BackgroundManager {
     markForNotification(task: BackgroundTask): void;
     getPendingNotifications(sessionID: string): BackgroundTask[];
     clearNotifications(sessionID: string): void;
+    hasPendingNotifications(sessionID: string): boolean;
+    consumePendingNotifications(sessionID: string): PendingNotification[];
     private clearNotificationsForTask;
     private startPolling;
     private stopPolling;

package/dist/features/background-agent/types.d.ts

@@ -32,6 +32,10 @@ export interface BackgroundTask {
     concurrencyKey?: string;
     /** Parent session's agent name for notification */
     parentAgent?: string;
+    /** Last message count for stability detection */
+    lastMsgCount?: number;
+    /** Number of consecutive polls with stable message count */
+    stablePolls?: number;
 }
 export interface LaunchInput {
     description: string;

package/dist/features/boulder-state/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./types";
 export * from "./constants";
 export * from "./storage";
+export * from "./unified-state";

package/dist/features/boulder-state/unified-state.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Unified Workflow State
+ *
+ * Merges boulder.json (Sisyphus), conductor tracks (Maestro), and design phases
+ * into a single unified state for seamless Maestro-Sisyphus integration.
+ */
+/**
+ * Unified workflow state combining boulder, conductor, and design phases
+ */
+export interface UnifiedWorkflowState {
+    /** Version for migration support */
+    version: "1.0.0";
+    /** Boulder state (Sisyphus plan tracking) */
+    boulder: {
+        activePlan: string | null;
+        planName: string | null;
+        startedAt: string | null;
+        sessionIds: string[];
+    };
+    /** Plan progress */
+    progress: {
+        total: number;
+        completed: number;
+        inProgress: number;
+        blocked: number;
+        isComplete: boolean;
+        percentage: number;
+    };
+    /** Maestro design phase state */
+    designPhase: {
+        currentPhase: number | null;
+        mode: "speed" | "ask" | "full" | null;
+        complexityScore: number | null;
+        oracleApproved: boolean | null;
+    };
+    /** Conductor tracks (for parallel execution) */
+    tracks: Array<{
+        id: string;
+        name: string;
+        phase: "design" | "planning" | "ready" | "executing" | "completed";
+        taskCount: number;
+        completedCount: number;
+    }>;
+    /** TDD state (for enforcement) */
+    tdd: {
+        currentCycle: "red" | "green" | "refactor" | null;
+        lastTestRun: string | null;
+        testsPassing: boolean | null;
+        failingTestName: string | null;
+    };
+    /** Timestamps */
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Get the unified state file path
+ */
+export declare function getUnifiedStateFilePath(directory: string): string;
+/**
+ * Read unified workflow state
+ */
+export declare function readUnifiedState(directory: string): UnifiedWorkflowState | null;
+/**
+ * Write unified workflow state
+ */
+export declare function writeUnifiedState(directory: string, state: UnifiedWorkflowState): boolean;
+/**
+ * Create empty unified state
+ */
+export declare function createEmptyUnifiedState(): UnifiedWorkflowState;
+/**
+ * Update design phase in unified state
+ */
+export declare function updateDesignPhase(directory: string, phase: number, mode?: "speed" | "ask" | "full"): boolean;
+/**
+ * Update TDD cycle state
+ */
+export declare function updateTddState(directory: string, cycle: "red" | "green" | "refactor", testsPassing?: boolean, failingTestName?: string): boolean;
+/**
+ * Update progress in unified state
+ */
+export declare function updateProgress(directory: string, progress: Partial<UnifiedWorkflowState["progress"]>): boolean;
+/**
+ * Start a new workflow from a plan
+ */
+export declare function startWorkflow(directory: string, planPath: string, sessionId: string): UnifiedWorkflowState;

package/dist/features/maestro/hooks/index.d.ts

@@ -0,0 +1,16 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare const MAESTRO_HOOK_NAME = "maestro-mode-detector";
+interface MaestroHookInput {
+    sessionID: string;
+    messageID?: string;
+}
+interface MaestroHookOutput {
+    parts: Array<{
+        type: string;
+        text?: string;
+    }>;
+}
+export declare function createMaestroModeDetectorHook(ctx: PluginInput): {
+    "chat.message": (input: MaestroHookInput, output: MaestroHookOutput) => Promise<void>;
+};
+export { createMaestroModeDetectorHook as createMaestroHook };

package/dist/features/maestro/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./skills/index";
+export * from "./hooks/index";
+export * from "./utils/index";
+export * from "./types";

package/dist/features/maestro/skills/index.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltinSkill } from "../../builtin-skills/types";
+export declare const tddSkill: BuiltinSkill;
+export declare const agentMailSkill: BuiltinSkill;
+export declare function createMaestroSkills(): BuiltinSkill[];

package/dist/features/maestro/types.d.ts

@@ -0,0 +1,42 @@
+export type MaestroMode = "ci" | "co" | "ca";
+export interface ModeDetectionResult {
+    mode: MaestroMode;
+    reason: string;
+    epicCount: number;
+    readyBeadCount: number;
+    parallelGroups: string[][];
+    skills: string[];
+}
+export interface ParsedBead {
+    id: string;
+    title: string;
+    epicId?: string;
+    epicTitle?: string;
+    priority: number;
+    dependencies: string[];
+    fileScope?: string[];
+    status: "pending" | "ready" | "in_progress" | "completed" | "blocked";
+}
+export interface ParsedEpic {
+    id: string;
+    title: string;
+    beads: ParsedBead[];
+    fileScope: string[];
+}
+export interface ParsedPlan {
+    name: string;
+    path: string;
+    epics: ParsedEpic[];
+    allBeads: ParsedBead[];
+    hasAutonomousFlag: boolean;
+}
+export interface MaestroContext {
+    mode: MaestroMode;
+    skills: string[];
+    planPath: string;
+    epicCount: number;
+    readyBeadCount: number;
+    beadSummary: string;
+}
+export declare const MODE_SKILLS: Record<MaestroMode, string[]>;
+export declare const MODE_DESCRIPTIONS: Record<MaestroMode, string>;

package/dist/features/maestro/utils/index.d.ts

@@ -0,0 +1,4 @@
+import type { ModeDetectionResult, ParsedPlan } from "../types";
+export declare function parsePlanToBeads(planContent: string, planPath: string): ParsedPlan;
+export declare function detectMode(plan: ParsedPlan): ModeDetectionResult;
+export declare function generateBeadSummary(plan: ParsedPlan): string;

package/dist/features/workflow-engine/contracts/v1/types.d.ts

@@ -295,6 +295,11 @@ export type WorkflowEvent = {
 } | {
     type: "plan:updated";
     plan: WorkflowPlan;
+} | {
+    type: "plan:ready";
+    planPath: string;
+    planName: string;
+    autoExecute?: boolean;
 } | {
     type: "task:created";
     task: WorkflowTask;
@@ -327,6 +332,10 @@ export type WorkflowEvent = {
     type: "execution:completed";
     success: boolean;
     summary?: string;
+} | {
+    type: "execution:requested";
+    planPath: string;
+    triggeredBy: "maestro" | "prometheus" | "manual";
 } | {
     type: "handoff:created";
     payload: HandoffPayload;

package/dist/hooks/background-notification/index.d.ts

@@ -6,7 +6,17 @@ interface Event {
 interface EventInput {
     event: Event;
 }
+interface ToolExecuteInput {
+    sessionID?: string;
+    tool: string;
+}
+interface ToolExecuteOutput {
+    title: string;
+    output: string;
+    metadata: unknown;
+}
 export declare function createBackgroundNotificationHook(manager: BackgroundManager): {
     event: ({ event }: EventInput) => Promise<void>;
+    "tool.execute.after": (input: ToolExecuteInput, output: ToolExecuteOutput) => Promise<void>;
 };
 export type { BackgroundNotificationHookConfig } from "./types";

package/dist/hooks/index.d.ts

@@ -28,3 +28,6 @@ export { createPrometheusMdOnlyHook } from "./prometheus-md-only";
 export { createTaskResumeInfoHook } from "./task-resume-info";
 export { createStartWorkHook } from "./start-work";
 export { createSisyphusOrchestratorHook } from "./sisyphus-orchestrator";
+export { createMaestroModeDetectorHook, MAESTRO_HOOK_NAME } from "../features/maestro/hooks";
+export { createMaestroSisyphusBridgeHook } from "./maestro-sisyphus-bridge";
+export { createTddEnforcementHook } from "./tdd-enforcement";

package/dist/hooks/maestro-sisyphus-bridge/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const HOOK_NAME = "maestro-sisyphus-bridge";
+export declare const PLAN_READY_PROMPT = "\n## Plan Ready for Execution\n\nA new work plan has been created by Prometheus:\n- **Plan**: $PLAN_NAME\n- **Path**: $PLAN_PATH\n\nWould you like to start execution now? \n- Type \"yes\" or \"start\" to begin Sisyphus execution\n- Type \"no\" to review the plan first\n\n[Auto-execution can be enabled in config: maestro.autoExecute: true]\n";
+export declare const AUTO_EXECUTE_PROMPT = "\n## Plan Ready - Auto-Executing\n\nA new work plan has been created by Prometheus:\n- **Plan**: $PLAN_NAME\n- **Path**: $PLAN_PATH\n\n**Auto-execution is enabled (maestro.autoExecute: true)**\n\nStarting Sisyphus execution automatically...\n\nRun /start-work now to begin executing the plan.\n";
+export declare const DESIGN_PHASE_CONTEXT = "\n## Current Maestro Design Phase\n\nYou are operating within a Maestro workflow at **Phase $PHASE/10**:\n| Phase | Name | Status |\n|-------|------|--------|\n| 1 | DISCOVER (Diverge) | $P1 |\n| 2 | DEFINE (Converge) | $P2 |\n| 3 | DEVELOP (Diverge) | $P3 |\n| 4 | VERIFY (Oracle) | $P4 |\n| 5 | DECOMPOSE (Beads) | $P5 |\n| 6 | VALIDATE (Dependencies) | $P6 |\n| 7 | ASSIGN (Tracks) | $P7 |\n| 8 | READY (Handoff) | $P8 |\n| 9 | EXECUTE (Implementation) | $P9 |\n| 10 | FINISH (Archive) | $P10 |\n\nRespect the current phase constraints. Do not skip ahead.\n";
+export declare const TDD_GATE_MESSAGES: {
+    RED_NO_FAILING_TEST: string;
+    GREEN_TEST_NOT_PASSING: string;
+    REFACTOR_TESTS_FAILED: string;
+};

package/dist/hooks/maestro-sisyphus-bridge/index.d.ts

@@ -0,0 +1,53 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { MaestroConfig } from "../../config/schema";
+export * from "./constants";
+interface BridgeHookInput {
+    sessionID: string;
+    messageID?: string;
+}
+interface BridgeHookOutput {
+    parts: Array<{
+        type: string;
+        text?: string;
+    }>;
+    messages?: Array<{
+        role: string;
+        content: string;
+    }>;
+}
+interface WorkflowProgress {
+    planPath: string;
+    planName: string;
+    totalTasks: number;
+    completedTasks: number;
+    currentTask?: string;
+    phase: number;
+    lastUpdated: string;
+}
+export declare function getWorkflowProgress(): WorkflowProgress | null;
+export declare function updateWorkflowProgress(update: Partial<WorkflowProgress>): void;
+export declare function createMaestroSisyphusBridgeHook(ctx: PluginInput, maestroConfig?: MaestroConfig): {
+    /**
+     * Inject plan ready notification into chat
+     */
+    "chat.message": (input: BridgeHookInput, output: BridgeHookOutput) => Promise<void>;
+    /**
+     * Track design phase changes and task progress (bidirectional events)
+     */
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+    }, output: {
+        result?: unknown;
+        message?: string;
+    }) => Promise<void>;
+    /**
+     * Inject design phase context into Sisyphus agent prompts
+     */
+    "agent.prompt.before": (input: {
+        agentName: string;
+        sessionID: string;
+    }, output: {
+        systemPrompt?: string;
+    }) => Promise<void>;
+};

package/dist/hooks/tdd-enforcement/constants.d.ts

@@ -0,0 +1,16 @@
+export declare const HOOK_NAME = "tdd-enforcement";
+export declare const TDD_PHASES: {
+    readonly RED: "red";
+    readonly GREEN: "green";
+    readonly REFACTOR: "refactor";
+};
+export type TddPhase = typeof TDD_PHASES[keyof typeof TDD_PHASES];
+export declare const TDD_GATE_PROMPTS: {
+    RED_REQUIRES_FAILING_TEST: string;
+    GREEN_REQUIRES_PASSING_TEST: string;
+    REFACTOR_REQUIRES_GREEN_TESTS: string;
+    BLOCK_IMPLEMENTATION_NO_TEST: string;
+    BLOCK_REFACTOR_TESTS_FAILING: string;
+};
+export declare const IMPLEMENTATION_INDICATORS: string[];
+export declare const TEST_FILE_PATTERNS: string[];

package/dist/hooks/tdd-enforcement/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * TDD Enforcement Hook
+ *
+ * Engine-level TDD gate that enforces RED-GREEN-REFACTOR cycle
+ * when maestro.enforceTdd is enabled.
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { MaestroConfig } from "../../config/schema";
+export * from "./constants";
+interface TddHookInput {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}
+interface TddHookOutput {
+    args: Record<string, unknown>;
+    message?: string;
+    blocked?: boolean;
+}
+export declare function createTddEnforcementHook(ctx: PluginInput, maestroConfig?: MaestroConfig): {
+    /**
+     * Pre-tool hook to enforce TDD gates
+     */
+    "tool.execute.before"?: undefined;
+    /**
+     * Post-tool hook to track test results
+     */
+    "tool.execute.after"?: undefined;
+    /**
+     * Inject TDD context into agent prompts
+     */
+    "agent.prompt.before"?: undefined;
+} | {
+    /**
+     * Pre-tool hook to enforce TDD gates
+     */
+    "tool.execute.before": (input: TddHookInput, output: TddHookOutput) => Promise<void>;
+    /**
+     * Post-tool hook to track test results
+     */
+    "tool.execute.after": (input: TddHookInput, output: {
+        result?: unknown;
+        message?: string;
+    }) => Promise<void>;
+    /**
+     * Inject TDD context into agent prompts
+     */
+    "agent.prompt.before": (input: {
+        agentName: string;
+        sessionID: string;
+    }, output: {
+        systemPrompt?: string;
+    }) => Promise<void>;
+};