opencode-orchestrator 1.0.36 → 1.0.38

package/README.md

@@ -67,6 +67,61 @@ OpenCode Orchestrator manages complex software tasks through **parallel multi-ag
                 [MISSION SEALED]
 ```
 
+
+```mermaid
+graph TD
+    %% Nodes
+    User(("User 👤"))
+    LLM(("Brain (LLM) 🧠"))
+    Tool(("Tool 🛠️"))
+    
+    %% 1. Chat Processing
+    subgraph Chat_Processing [Chat Processing]
+        UserAct[UserActivity Hook]
+        MissionChat[MissionControl Hook - Start]
+    end
+
+    %% 2. Pre-Execution
+    subgraph Pre_Execution [Pre-Execution Guard]
+        RoleGuard[StrictRoleGuard]
+    end
+
+    %% 3. Post-Execution
+    subgraph Post_Execution [Post-Execution Processing]
+        Scanner[SecretScanner]
+        UI[AgentUI Hook]
+        Resource[ResourceControl - Track]
+    end
+
+    %% 4. Completion
+    subgraph Completion [Completion & Loop Control]
+        Sanity[SanityCheck]
+        MissionDone[MissionControl Hook - Loop]
+        ResourceComp[ResourceControl - Compact]
+    end
+
+    %% Flow Connections
+    User -->|1. Message| UserAct
+    UserAct --> MissionChat
+    MissionChat -->|2. Modified Prompt| LLM
+    
+    LLM -->|3. Tool Call| RoleGuard
+    RoleGuard -->|4. Safe?| Tool
+    RoleGuard -.->|Blocked| LLM
+    
+    Tool -->|5. Output| Scanner
+    Scanner --> UI
+    UI --> Resource
+    Resource -->|6. Result| LLM
+    
+    LLM -->|7. Turn Done| Sanity
+    Sanity --> MissionDone
+    
+    MissionDone -.->|No Seal: Auto-Continue| LLM
+    MissionDone -->|Yes Seal: Complete| ResourceComp
+    ResourceComp -->|9. Final Response| User
+```
+
 ---
 
 ## 🚀 Agents
@@ -94,6 +149,7 @@ OpenCode Orchestrator manages complex software tasks through **parallel multi-ag
 OpenCode Orchestrator was developed to solve the "sequential bottleneck" in AI-assisted coding. By treating agents as distributed processing units rather than just chat interfaces, we aim to provide a more reliable and scalable autonomous engineering experience.
 
 [Full Developer's Note →](docs/DEVELOPERS_NOTE.md)
+
 [System Architecture →](docs/SYSTEM_ARCHITECTURE.md)
 
 ---

package/dist/core/context/context-window-monitor.d.ts

@@ -24,6 +24,13 @@ export declare const CONTEXT_MONITOR_CONFIG: {
     /** Minimum time between alerts (ms) */
     readonly ALERT_COOLDOWN_MS: 60000;
 };
+export interface MonitorState {
+    lastAlertTime: number;
+    lastAlertLevel: "info" | "warning" | "critical" | null;
+    isMonitoring: boolean;
+    intervalId?: ReturnType<typeof setInterval>;
+}
+export declare function getMonitorState(sessionID: string): MonitorState;
 /**
  * Calculate context usage percentage
  */

package/dist/hooks/compatibility/external-plugin.d.ts

@@ -0,0 +1,10 @@
+/**
+ * External Plugin Compatibility Hook
+ *
+ * Detects if other major plugins are present and ensures orchestrator plays nicely.
+ */
+import type { ChatMessageHook, AssistantDoneHook, HookContext } from "../types.js";
+export declare class ExternalPluginCompatHook implements ChatMessageHook, AssistantDoneHook {
+    name: string;
+    execute(ctx: HookContext, input: any): Promise<any>;
+}

package/dist/hooks/constants.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Hook Constants
+ * Defines strict constant values for hook actions and statuses.
+ */
+export declare const HOOK_ACTIONS: {
+    readonly CONTINUE: "continue";
+    readonly STOP: "stop";
+    readonly ALLOW: "allow";
+    readonly BLOCK: "block";
+    readonly MODIFY: "modify";
+    readonly INJECT: "inject";
+    readonly PROCESS: "process";
+    readonly INTERCEPT: "intercept";
+};
+export declare const HOOK_NAMES: {
+    readonly SANITY_CHECK: "SanityCheck";
+    readonly MISSION_LOOP: "MissionLoop";
+    readonly STRICT_ROLE_GUARD: "StrictRoleGuard";
+    readonly SECRET_SCANNER: "SecretScanner";
+    readonly AGENT_UI: "AgentUI";
+    readonly RESOURCE_CONTROL: "ResourceControl";
+    readonly SLASH_COMMAND: "SlashCommandDispatcher";
+    readonly USER_ACTIVITY: "UserActivity";
+};

package/dist/hooks/custom/agent-ui.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Agent UI Hook
+ *
+ * Decorates tool outputs with UI elements:
+ * - Agent headers (e.g. [P] PLANNER Working...)
+ * - Task ID tracking
+ */
+import type { PostToolUseHook, HookContext } from "../types.js";
+export declare class AgentUIHook implements PostToolUseHook {
+    name: "AgentUI";
+    execute(ctx: HookContext, tool: string, input: any, output: {
+        title: string;
+        output: string;
+        metadata: any;
+    }): Promise<{
+        output?: undefined;
+    } | {
+        output: string;
+    }>;
+}

package/dist/hooks/custom/resource-control.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Resource Control Hook
+ *
+ * Unifies resource tracking, monitoring, and active memory compaction.
+ * Replaces separate ResourceUsageHook and MemoryCompactionHook.
+ */
+import type { PostToolUseHook, AssistantDoneHook, HookContext } from "../types.js";
+export declare class ResourceControlHook implements PostToolUseHook, AssistantDoneHook {
+    name: "ResourceControl";
+    private lastCompactionTime;
+    execute(ctx: HookContext, toolOrText: string, input?: any, output?: any): Promise<any>;
+    private checkMemoryHealth;
+    private generateCompactionPrompt;
+}

package/dist/hooks/custom/secret-scanner.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Secret Scanner Hook
+ *
+ * Scans tool outputs for potential secrets (API Keys, etc) and masks them.
+ * This prevents leaking secrets into the context window or logs.
+ */
+import type { PostToolUseHook, HookContext } from "../types.js";
+export declare class SecretScannerHook implements PostToolUseHook {
+    name: "SecretScanner";
+    execute(ctx: HookContext, tool: string, input: any, output: {
+        title: string;
+        output: string;
+        metadata: any;
+    }): Promise<{
+        output: string;
+    } | {
+        output?: undefined;
+    }>;
+}

package/dist/hooks/custom/strict-role-guard.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Strict Role Guard Hook
+ *
+ * Enforces role-based access control (RBAC) for agents.
+ * - Planner: Cannot write code or run commands.
+ * - Reviewer: Cannot write code (only review).
+ */
+import type { PreToolUseHook, HookContext } from "../types.js";
+export declare class StrictRoleGuardHook implements PreToolUseHook {
+    name: "StrictRoleGuard";
+    execute(ctx: HookContext, tool: string, args: any): Promise<{
+        action: "block";
+        reason: string;
+    } | {
+        action: "allow";
+        reason?: undefined;
+    }>;
+}

package/dist/hooks/custom/user-activity.d.ts

@@ -0,0 +1,11 @@
+/**
+ * User Activity Hook
+ *
+ * Tracks user interaction (chat messages) to pause auto-continuation/loops
+ * and update activity timestamps.
+ */
+import type { ChatMessageHook, HookContext } from "../types.js";
+export declare class UserActivityHook implements ChatMessageHook {
+    name: "UserActivity";
+    execute(ctx: HookContext, message: string): Promise<any>;
+}

package/dist/hooks/features/mission-loop.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Mission Loop Hook
+ *
+ * Handles:
+ * - Mission seal detection (Stop)
+ * - Auto-continuation injection (Loop)
+ * - User cancellation detection
+ */
+import type { AssistantDoneHook, ChatMessageHook, HookContext } from "../types.js";
+export declare class MissionControlHook implements AssistantDoneHook, ChatMessageHook {
+    name: "MissionLoop";
+    execute(ctx: HookContext, text: string): Promise<any>;
+    private handleChatCommand;
+    private handleMissionSeal;
+}

package/dist/hooks/features/sanity-check.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Sanity Check Hook
+ * Implements output anomaly detection.
+ */
+import type { PostToolUseHook, AssistantDoneHook, HookContext } from "../types.js";
+export declare class SanityCheckHook implements PostToolUseHook, AssistantDoneHook {
+    name: "SanityCheck";
+    execute(ctx: HookContext, toolOrText: string, input?: any, output?: {
+        title: string;
+        output: string;
+        metadata: any;
+    }): Promise<any>;
+    private checkToolOutput;
+    private checkFinalText;
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Initialize Hooks
+ * Registers all default hooks.
+ */
+export declare function initializeHooks(): void;

package/dist/hooks/registry.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Hook Registry
+ * Manages registration and execution of hooks.
+ */
+import type { PreToolUseHook, PostToolUseHook, ChatMessageHook, AssistantDoneHook, HookContext, HookResult } from "./types.js";
+import { HOOK_ACTIONS } from "./constants.js";
+export declare class HookRegistry {
+    private static instance;
+    private preToolHooks;
+    private postToolHooks;
+    private chatHooks;
+    private doneHooks;
+    private constructor();
+    static getInstance(): HookRegistry;
+    registerPreTool(hook: PreToolUseHook): void;
+    registerPostTool(hook: PostToolUseHook): void;
+    registerChat(hook: ChatMessageHook): void;
+    registerDone(hook: AssistantDoneHook): void;
+    executePreTool(ctx: HookContext, tool: string, args: any): Promise<{
+        action: typeof HOOK_ACTIONS.ALLOW | typeof HOOK_ACTIONS.BLOCK | typeof HOOK_ACTIONS.MODIFY;
+        modifiedArgs?: any;
+        reason?: string;
+    }>;
+    executePostTool(ctx: HookContext, tool: string, input: any, output: {
+        title: string;
+        output: string;
+        metadata: any;
+    }): Promise<void>;
+    executeChat(ctx: HookContext, message: string): Promise<{
+        action: typeof HOOK_ACTIONS.PROCESS | typeof HOOK_ACTIONS.INTERCEPT;
+        modifiedMessage?: string;
+    }>;
+    executeDone(ctx: HookContext, finalText: string): Promise<HookResult>;
+}

package/dist/hooks/types.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Hook System Types
+ * Defines the contract for all hooks in the system.
+ */
+import { HOOK_ACTIONS } from "./constants.js";
+export interface HookContext {
+    sessionID: string;
+    agent?: string;
+    directory: string;
+    sessions: Map<string, any>;
+}
+export type HookResult = {
+    action: typeof HOOK_ACTIONS.CONTINUE;
+} | {
+    action: typeof HOOK_ACTIONS.STOP;
+    reason?: string;
+} | {
+    action: typeof HOOK_ACTIONS.INJECT;
+    prompts: string[];
+};
+/**
+ * Pre-Tool Execution Hook
+ * Runs before a tool is executed. Can block execution or modify arguments.
+ */
+export interface PreToolUseHook {
+    name: string;
+    execute(context: HookContext, tool: string, args: any): Promise<{
+        action: typeof HOOK_ACTIONS.ALLOW | typeof HOOK_ACTIONS.BLOCK | typeof HOOK_ACTIONS.MODIFY;
+        modifiedArgs?: any;
+        reason?: string;
+    }>;
+}
+/**
+ * Post-Tool Execution Hook
+ * Runs after a tool is executed. Can analyze output or trigger side effects.
+ */
+export interface PostToolUseHook {
+    name: string;
+    execute(context: HookContext, tool: string, input: any, output: {
+        title: string;
+        output: string;
+        metadata: any;
+    }): Promise<{
+        output?: string;
+    }>;
+}
+/**
+ * Chat Message Hook
+ * Runs when a user sends a message. Can intercept commands.
+ */
+export interface ChatMessageHook {
+    name: string;
+    execute(context: HookContext, message: string): Promise<{
+        action: typeof HOOK_ACTIONS.PROCESS | typeof HOOK_ACTIONS.INTERCEPT;
+        modifiedMessage?: string;
+    }>;
+}
+/**
+ * Assistant Done Hook
+ * Runs when the assistant finishes a turn. Can inject continuation prompts.
+ */
+export interface AssistantDoneHook {
+    name: string;
+    execute(context: HookContext, finalText: string): Promise<HookResult>;
+}