@hiai-gg/hiai-opencode 0.2.1 → 0.2.2

package/dist/config/schema/hiai-opencode-config.d.ts

@@ -1057,134 +1057,6 @@ export declare const HiaiOpenCodeConfigSchema: z.ZodObject<{
                 variant: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
-        multimodal: z.ZodOptional<z.ZodObject<{
-            model: z.ZodOptional<z.ZodString>;
-            fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
-                model: z.ZodString;
-                variant: z.ZodOptional<z.ZodString>;
-                reasoningEffort: z.ZodOptional<z.ZodEnum<{
-                    none: "none";
-                    minimal: "minimal";
-                    low: "low";
-                    medium: "medium";
-                    high: "high";
-                    xhigh: "xhigh";
-                }>>;
-                temperature: z.ZodOptional<z.ZodNumber>;
-                top_p: z.ZodOptional<z.ZodNumber>;
-                maxTokens: z.ZodOptional<z.ZodNumber>;
-                thinking: z.ZodOptional<z.ZodObject<{
-                    type: z.ZodEnum<{
-                        enabled: "enabled";
-                        disabled: "disabled";
-                    }>;
-                    budgetTokens: z.ZodOptional<z.ZodNumber>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                model: z.ZodString;
-                variant: z.ZodOptional<z.ZodString>;
-                reasoningEffort: z.ZodOptional<z.ZodEnum<{
-                    none: "none";
-                    minimal: "minimal";
-                    low: "low";
-                    medium: "medium";
-                    high: "high";
-                    xhigh: "xhigh";
-                }>>;
-                temperature: z.ZodOptional<z.ZodNumber>;
-                top_p: z.ZodOptional<z.ZodNumber>;
-                maxTokens: z.ZodOptional<z.ZodNumber>;
-                thinking: z.ZodOptional<z.ZodObject<{
-                    type: z.ZodEnum<{
-                        enabled: "enabled";
-                        disabled: "disabled";
-                    }>;
-                    budgetTokens: z.ZodOptional<z.ZodNumber>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>]>>]>>;
-            variant: z.ZodOptional<z.ZodString>;
-            category: z.ZodOptional<z.ZodString>;
-            skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            temperature: z.ZodOptional<z.ZodNumber>;
-            top_p: z.ZodOptional<z.ZodNumber>;
-            prompt: z.ZodOptional<z.ZodString>;
-            prompt_append: z.ZodOptional<z.ZodString>;
-            tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
-            disable: z.ZodOptional<z.ZodBoolean>;
-            description: z.ZodOptional<z.ZodString>;
-            mode: z.ZodOptional<z.ZodEnum<{
-                primary: "primary";
-                subagent: "subagent";
-                all: "all";
-            }>>;
-            color: z.ZodOptional<z.ZodString>;
-            permission: z.ZodOptional<z.ZodObject<{
-                edit: z.ZodOptional<z.ZodEnum<{
-                    allow: "allow";
-                    deny: "deny";
-                    ask: "ask";
-                }>>;
-                bash: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-                    allow: "allow";
-                    deny: "deny";
-                    ask: "ask";
-                }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
-                    allow: "allow";
-                    deny: "deny";
-                    ask: "ask";
-                }>>]>>;
-                webfetch: z.ZodOptional<z.ZodEnum<{
-                    allow: "allow";
-                    deny: "deny";
-                    ask: "ask";
-                }>>;
-                task: z.ZodOptional<z.ZodEnum<{
-                    allow: "allow";
-                    deny: "deny";
-                    ask: "ask";
-                }>>;
-                doom_loop: z.ZodOptional<z.ZodEnum<{
-                    allow: "allow";
-                    deny: "deny";
-                    ask: "ask";
-                }>>;
-                external_directory: z.ZodOptional<z.ZodEnum<{
-                    allow: "allow";
-                    deny: "deny";
-                    ask: "ask";
-                }>>;
-            }, z.core.$strip>>;
-            maxTokens: z.ZodOptional<z.ZodNumber>;
-            thinking: z.ZodOptional<z.ZodObject<{
-                type: z.ZodEnum<{
-                    enabled: "enabled";
-                    disabled: "disabled";
-                }>;
-                budgetTokens: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-            reasoningEffort: z.ZodOptional<z.ZodEnum<{
-                none: "none";
-                minimal: "minimal";
-                low: "low";
-                medium: "medium";
-                high: "high";
-                xhigh: "xhigh";
-            }>>;
-            textVerbosity: z.ZodOptional<z.ZodEnum<{
-                low: "low";
-                medium: "medium";
-                high: "high";
-            }>>;
-            providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            ultrawork: z.ZodOptional<z.ZodObject<{
-                model: z.ZodOptional<z.ZodString>;
-                variant: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-            compaction: z.ZodOptional<z.ZodObject<{
-                model: z.ZodOptional<z.ZodString>;
-                variant: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
         "quality-guardian": z.ZodOptional<z.ZodObject<{
             model: z.ZodOptional<z.ZodString>;
             fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{

package/dist/config/types.d.ts

@@ -22,9 +22,9 @@ export interface ModelSlotsConfig {
     vision?: ModelSlotConfig;
     sub?: ModelSlotConfig;
 }
-export declare const CANONICAL_AGENT_NAMES: readonly ["bob", "manager", "strategist", "critic", "coder", "designer", "sub", "researcher", "multimodal", "quality-guardian", "writer", "agent-skills"];
+export declare const CANONICAL_AGENT_NAMES: readonly ["bob", "manager", "strategist", "critic", "coder", "designer", "sub", "researcher", "vision", "quality-guardian", "writer", "agent-skills"];
 export type CanonicalAgentName = (typeof CANONICAL_AGENT_NAMES)[number];
-export declare const LEGACY_AGENT_ALIAS_NAMES: readonly ["general", "zoe", "build", "pre-plan", "vision", "logician", "librarian", "explore", "ui", "code-reviewer", "systematic-debugger", "mindmodel", "ledger-creator", "bootstrapper", "project-initializer", "guard", "brainstormer"];
+export declare const LEGACY_AGENT_ALIAS_NAMES: readonly ["general", "zoe", "build", "pre-plan", "multimodal", "ui", "logician", "librarian", "explore", "code-reviewer", "systematic-debugger", "mindmodel", "ledger-creator", "bootstrapper", "project-initializer", "guard", "brainstormer"];
 export type LegacyAgentAliasName = (typeof LEGACY_AGENT_ALIAS_NAMES)[number];
 export declare const LEGACY_AGENT_ALIAS_TO_CANONICAL: Record<LegacyAgentAliasName, CanonicalAgentName>;
 export type KnownAgentName = CanonicalAgentName | LegacyAgentAliasName;

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

@@ -0,0 +1,46 @@
+import type { BackgroundTask } from "./types";
+import type { BackgroundTaskNotificationTask } from "./background-task-notification-template";
+export interface NotifierAdapter {
+    client: {
+        session: {
+            messages: (input: {
+                path: {
+                    id: string;
+                };
+            }) => Promise<unknown>;
+            promptAsync: (input: {
+                path: {
+                    id: string;
+                };
+                body: {
+                    noReply?: boolean;
+                    agent?: string;
+                    model?: {
+                        providerID: string;
+                        modelID: string;
+                    };
+                    variant?: string;
+                    tools?: Record<string, boolean | "allow" | "deny" | "ask">;
+                    parts: Array<{
+                        type: "text";
+                        text: string;
+                    }>;
+                };
+            }) => Promise<unknown>;
+        };
+    };
+    directory: string;
+    enableParentSessionNotifications: boolean;
+    tasks: Map<string, BackgroundTask>;
+    completedTaskSummaries: Map<string, BackgroundTaskNotificationTask[]>;
+    pendingByParent: Map<string, Set<string>>;
+    pendingNotifications: Map<string, string[]>;
+    notificationQueueByParent: Map<string, Promise<void>>;
+    queuePendingNotification: (parentSessionID: string, notification: string) => void;
+    scheduleTaskRemoval: (taskId: string, rescheduleCount?: number) => void;
+    clearNotificationsForTask: (taskId: string) => void;
+    cleanupPendingByParent: (task: BackgroundTask) => void;
+    getTasksByParentSession: (sessionID: string) => BackgroundTask[];
+}
+export declare function enqueueNotificationForParent(adapter: NotifierAdapter, parentSessionID: string | undefined, operation: () => Promise<void>): Promise<void>;
+export declare function notifyParentSession(adapter: NotifierAdapter, task: BackgroundTask): Promise<void>;

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

@@ -0,0 +1,40 @@
+import type { BackgroundTask, LaunchInput } from "./types";
+export interface MessagePartInfo {
+    id?: string;
+    sessionID?: string;
+    type?: string;
+    tool?: string;
+    state?: {
+        status?: string;
+        input?: Record<string, unknown>;
+    };
+}
+export interface EventProperties {
+    sessionID?: string;
+    info?: {
+        id?: string;
+    };
+    [key: string]: unknown;
+}
+export interface BackgroundEvent {
+    type: string;
+    properties?: EventProperties;
+}
+export interface Todo {
+    content: string;
+    status: string;
+    priority: string;
+    id: string;
+}
+export interface QueueItem {
+    task: BackgroundTask;
+    input: LaunchInput;
+}
+export interface SubagentSessionCreatedEvent {
+    sessionID: string;
+    parentID: string;
+    title: string;
+}
+export type OnSubagentSessionCreated = (event: SubagentSessionCreatedEvent) => Promise<void>;
+export declare const MAX_TASK_REMOVAL_RESCHEDULES = 6;
+export declare function resolveMessagePartInfo(properties: EventProperties | undefined): MessagePartInfo | undefined;

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

@@ -3,23 +3,8 @@ import type { BackgroundTask, LaunchInput, ResumeInput } from "./types";
 import { TaskHistory } from "./task-history";
 import type { BackgroundTaskConfig, TmuxConfig } from "../../config/schema";
 import { type SubagentSpawnContext } from "./subagent-spawn-limits";
-interface EventProperties {
-    sessionID?: string;
-    info?: {
-        id?: string;
-    };
-    [key: string]: unknown;
-}
-interface Event {
-    type: string;
-    properties?: EventProperties;
-}
-export interface SubagentSessionCreatedEvent {
-    sessionID: string;
-    parentID: string;
-    title: string;
-}
-export type OnSubagentSessionCreated = (event: SubagentSessionCreatedEvent) => Promise<void>;
+import type { OnSubagentSessionCreated, BackgroundEvent } from "./manager-types";
+export type { SubagentSessionCreatedEvent, OnSubagentSessionCreated } from "./manager-types";
 export declare class BackgroundManager {
     private tasks;
     private notifications;
@@ -94,7 +79,7 @@ export declare class BackgroundManager {
     private clearSessionOutputObserved;
     private clearSessionTodoObservation;
     private hasOutputSignalFromPart;
-    handleEvent(event: Event): void;
+    handleEvent(event: BackgroundEvent): void;
     private handleSessionErrorEvent;
     private tryFallbackRetry;
     markForNotification(task: BackgroundTask): void;
@@ -164,4 +149,3 @@ export declare class BackgroundManager {
     shutdown(): Promise<void>;
     private enqueueNotificationForParent;
 }
-export {};

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

@@ -0,0 +1,51 @@
+import type { BackgroundTaskConfig } from "../../config/schema";
+import type { ConcurrencyManager } from "./concurrency";
+import type { TaskHistory } from "./task-history";
+import { checkAndInterruptStaleTasks } from "./task-poller";
+import type { BackgroundTask, LaunchInput } from "./types";
+type OpencodeClient = Parameters<typeof checkAndInterruptStaleTasks>[0]["client"];
+interface QueueItem {
+    task: BackgroundTask;
+    input: LaunchInput;
+}
+export interface PollingManagerAdapter {
+    readonly tasks: Map<string, BackgroundTask>;
+    readonly notifications: Map<string, BackgroundTask[]>;
+    readonly client: OpencodeClient;
+    readonly directory: string;
+    readonly config?: BackgroundTaskConfig;
+    readonly concurrencyManager: ConcurrencyManager;
+    readonly taskHistory: TaskHistory;
+    readonly queuesByKey: Map<string, QueueItem[]>;
+    readonly completionTimers: Map<string, ReturnType<typeof setTimeout>>;
+    readonly idleDeferralTimers: Map<string, ReturnType<typeof setTimeout>>;
+    tryFallbackRetry(task: BackgroundTask, errorInfo: {
+        name?: string;
+        message?: string;
+    }, source: string): Promise<boolean>;
+    tryCompleteTask(task: BackgroundTask, source: string): Promise<boolean>;
+    validateSessionHasOutput(sessionID: string): Promise<boolean>;
+    checkSessionTodos(sessionID: string): Promise<boolean>;
+    enqueueNotificationForParent(parentSessionID: string | undefined, operation: () => Promise<void>): Promise<void>;
+    notifyParentSession(task: BackgroundTask): Promise<void>;
+    unregisterRootDescendant(rootSessionID: string): void;
+    cleanupPendingByParent(task: BackgroundTask): void;
+    clearNotificationsForTask(taskId: string): void;
+    scheduleTaskRemoval(taskId: string): void;
+    markForNotification(task: BackgroundTask): void;
+}
+export declare class TaskPollingManager {
+    private adapter;
+    private pollingInterval?;
+    private pollingInFlight;
+    constructor(adapter: PollingManagerAdapter);
+    startPolling(): void;
+    stopPolling(): void;
+    hasRunningTasks(): boolean;
+    private verifySessionExists;
+    private pruneStaleTasksAndNotifications;
+    private checkAndInterruptStaleTasks;
+    private failCrashedTask;
+    private pollRunningTasks;
+}
+export {};

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

@@ -4,6 +4,7 @@
  * Handles reading/writing boulder.json for active plan tracking.
  */
 import type { BoulderState, PlanProgress, TaskSessionState } from "./types";
+export declare function validatePlanName(planName: string): void;
 export declare function getBoulderFilePath(directory: string): string;
 /**
  * Read boulder state — v2 compatible

package/dist/features/builtin-commands/templates/loop.d.ts

@@ -0,0 +1,2 @@
+export declare const LOOP_COMMAND_TEMPLATE = "You are starting a Development Loop - a self-referential loop that runs until task completion.\n\n## How the Loop Works\n\n1. You will work on the task continuously\n2. When you believe the task is fully complete, output: `<promise>{{COMPLETION_PROMISE}}</promise>`\n3. If mode is \"ultrawork\", Critic must verify your work before the loop ends\n4. Maximum iterations: {{MAX_ITERATIONS}}\n\n## Modes\n\n| Mode | Max Iterations | Verification |\n|------|---------------|--------------|\n| normal | 100 | None |\n| ultrawork | 500 | Critic gate after first completion promise |\n\n## Exit Conditions\n\n1. **Normal mode**: Output `<promise>DONE</promise>` when fully complete\n2. **Ultrawork mode**: First `<promise>DONE</promise>` triggers Critic verification. Loop ends only after Critic verifies.\n3. **Max Iterations**: Loop stops automatically at limit\n4. **Cancel**: User runs `/cancel-loop` command\n\n## Your Task\n\nParse the arguments:\n- Task description (required)\n- --mode=normal|ultrawork (default: normal)\n- --completion-promise=TEXT (default: DONE)\n- --strategy=reset|continue (default: continue)\n\nBegin working on the task.";
+export declare const CANCEL_LOOP_TEMPLATE = "Cancel the currently active Development Loop.\n\nThis will:\n1. Stop the loop from continuing\n2. Clear the loop state file\n3. Allow the session to end normally\n\nCheck if a loop is active and cancel it. Inform the user of the result.";

package/dist/features/builtin-commands/templates/start-work.d.ts

@@ -1 +1 @@
-export declare const START_WORK_TEMPLATE = "You are starting a Bob work session.\n\n## ARGUMENTS\n\n- `/start-work [plan-name] [--worktree <path>]`\n  - `plan-name` (optional): name or partial match of the plan to start\n  - `--worktree <path>` (optional): absolute path to an existing git worktree to work in\n    - If specified and valid: hook pre-sets `worktree_path` in the active boulder registry entry\n    - If specified but invalid: you must run `git worktree add <path> <branch>` first\n    - If omitted: work directly in the current project directory (no worktree)\n\n## WHAT TO DO\n\n1. **Find available plans**: Search for Strategist-generated plan files at `.bob/plans/`\n\n2. **Check for active boulder state**: Read `.bob/boulder-registry/` for active plans\n\n3. **Decision logic**:\n   - If the plan already exists in `.bob/boulder-registry/` AND is NOT complete:\n     - **APPEND** current session to session_ids\n     - Continue work on existing plan\n   - If no active plan OR plan is complete:\n     - List available plan files\n     - If ONE plan: auto-select it\n     - If MULTIPLE plans: show list with timestamps, ask user to select\n\n4. **Worktree Setup** (ONLY when `--worktree` was explicitly specified and `worktree_path` not already set in the active registry entry):\n   1. `git worktree list --porcelain` - see available worktrees\n   2. Create: `git worktree add <absolute-path> <branch-or-HEAD>`\n   3. Update the active registry entry to add `\"worktree_path\": \"<absolute-path>\"`\n   4. All work happens inside that worktree directory\n\n5. **Create/Update active boulder registry entry**:\n   ```json\n   {\n     \"active_plan\": \"/absolute/path/to/plan.md\",\n     \"started_at\": \"ISO_TIMESTAMP\",\n     \"session_ids\": [\"session_id_1\", \"session_id_2\"],\n     \"plan_name\": \"plan-name\",\n     \"worktree_path\": \"/absolute/path/to/git/worktree\"\n   }\n   ```\n\n6. **Read the plan file** and start executing tasks according to guard workflow\n\n## OUTPUT FORMAT\n\nWhen listing plans for selection:\n```\nAvailable Work Plans\n\nCurrent Time: {ISO timestamp}\nSession ID: {current session id}\n\n1. [plan-name-1.md] - Modified: {date} - Progress: 3/10 tasks\n2. [plan-name-2.md] - Modified: {date} - Progress: 0/5 tasks\n\nWhich plan would you like to work on? (Enter number or plan name)\n```\n\nWhen resuming existing work:\n```\nResuming Work Session\n\nActive Plan: {plan-name}\nProgress: {completed}/{total} tasks\nSessions: {count} (appending current session)\nWorktree: {worktree_path}\n\nReading plan and continuing from last incomplete task...\n```\n\nWhen auto-selecting single plan:\n```\nStarting Work Session\n\nPlan: {plan-name}\nSession ID: {session_id}\nStarted: {timestamp}\nWorktree: {worktree_path}\n\nReading plan and beginning execution...\n```\n\n## CRITICAL\n\n- The session_id is injected by the hook - use it directly\n- Always update the active boulder registry entry BEFORE starting work\n- If `worktree_path` is set in the active registry entry, all work happens inside that worktree directory\n- Read the FULL plan file before delegating any tasks\n- Follow guard delegation protocols (7-section format)\n\n## TASK BREAKDOWN (MANDATORY)\n\nAfter reading the plan file, you MUST decompose every plan task into granular, implementation-level sub-steps and register ALL of them as task/todo items BEFORE starting any work.\n\n**How to break down**:\n- Each plan checkbox item (e.g., `- [ ] Add user authentication`) must be split into concrete, actionable sub-tasks\n- Sub-tasks should be specific enough that each one touches a clear set of files/functions\n- Include: file to modify, what to change, expected behavior, and how to verify\n- Do NOT leave any task vague - \"implement feature X\" is NOT acceptable; \"add validateToken() to src/auth/middleware.ts that checks JWT expiry and returns 401\" IS acceptable\n\n**Example breakdown**:\nPlan task: `- [ ] Add rate limiting to API`\n\u2192 Todo items:\n  1. Create `src/middleware/rate-limiter.ts` with sliding window algorithm (max 100 req/min per IP)\n  2. Add RateLimiter middleware to `src/app.ts` router chain, before auth middleware\n  3. Add rate limit headers (X-RateLimit-Limit, X-RateLimit-Remaining) to response in `rate-limiter.ts`\n  4. Add test: verify 429 response after exceeding limit in `src/middleware/rate-limiter.test.ts`\n  5. Add test: verify headers are present on normal responses\n\nRegister these as task/todo items so progress is tracked and visible throughout the session.\n\n## WORKTREE COMPLETION\n\nWhen ALL plan tasks are complete:\n1. Commit remaining changes in the worktree\n2. The plugin auto-syncs `.bob/notepads/` back to the main repo\n3. The worktree is auto-removed via `git worktree remove`\n4. The plan is deregistered from `boulder-registry/`\n\nDo NOT manually copy `.bob/` -- the plugin handles this.\n\n## PARALLEL PLANS\n\nMultiple plans can run simultaneously. Each plan lives in its own git worktree\nat `.opencode/worktrees/<plan-name>/` for complete filesystem isolation.\n\n- Auto-worktree: created automatically when a second plan starts - no `--worktree` needed\n- Manual worktree: `--worktree <path>` overrides the default location\n- Registry: `.bob/boulder-registry/{plan-name}.json` tracks each plan independently\n- Stop-continuation: only affects the calling session's plan, not other active plans\n";
+export declare const START_WORK_TEMPLATE = "You are starting an orchestration work session.\n\n**Orchestrator agent**: Bob is the primary orchestrator. For complex/waved plans, Bob dispatches Manager as a subagent for parallel wave coordination. For simple plans, Bob executes directly without dispatching Manager.\n\n## ARGUMENTS\n\n- `/start-work [plan-name] [--worktree <path>]`\n  - `plan-name` (optional): name or partial match of the plan to start\n  - `--worktree <path>` (optional): absolute path to an existing git worktree to work in\n    - If specified and valid: hook pre-sets `worktree_path` in the active boulder registry entry\n    - If specified but invalid: you must run `git worktree add <path> <branch>` first\n    - If omitted: work directly in the current project directory (no worktree)\n\n## WHAT TO DO\n\n1. **Find available plans**: Search for Strategist-generated plan files at `.bob/plans/`\n\n2. **Check for active boulder state**: Read `.bob/boulder-registry/` for active plans\n\n3. **Decision logic**:\n   - If the plan already exists in `.bob/boulder-registry/` AND is NOT complete:\n     - **APPEND** current session to session_ids\n     - Continue work on existing plan\n   - If no active plan OR plan is complete:\n     - List available plan files\n     - If ONE plan: auto-select it\n     - If MULTIPLE plans: show list with timestamps, ask user to select\n\n4. **Worktree Setup** (ONLY when `--worktree` was explicitly specified and `worktree_path` not already set in the active registry entry):\n   1. `git worktree list --porcelain` - see available worktrees\n   2. Create: `git worktree add <absolute-path> <branch-or-HEAD>`\n   3. Update the active registry entry to add `\"worktree_path\": \"<absolute-path>\"`\n   4. All work happens inside that worktree directory\n\n5. **Create/Update active boulder registry entry**:\n   ```json\n   {\n     \"active_plan\": \"/absolute/path/to/plan.md\",\n     \"started_at\": \"ISO_TIMESTAMP\",\n     \"session_ids\": [\"session_id_1\", \"session_id_2\"],\n     \"plan_name\": \"plan-name\",\n     \"worktree_path\": \"/absolute/path/to/git/worktree\"\n   }\n   ```\n\n6. **Read the plan file** and start executing tasks according to guard workflow\n\n## OUTPUT FORMAT\n\nWhen listing plans for selection:\n```\nAvailable Work Plans\n\nCurrent Time: {ISO timestamp}\nSession ID: {current session id}\n\n1. [plan-name-1.md] - Modified: {date} - Progress: 3/10 tasks\n2. [plan-name-2.md] - Modified: {date} - Progress: 0/5 tasks\n\nWhich plan would you like to work on? (Enter number or plan name)\n```\n\nWhen resuming existing work:\n```\nResuming Work Session\n\nActive Plan: {plan-name}\nProgress: {completed}/{total} tasks\nSessions: {count} (appending current session)\nWorktree: {worktree_path}\n\nReading plan and continuing from last incomplete task...\n```\n\nWhen auto-selecting single plan:\n```\nStarting Work Session\n\nPlan: {plan-name}\nSession ID: {session_id}\nStarted: {timestamp}\nWorktree: {worktree_path}\n\nReading plan and beginning execution...\n```\n\n## CRITICAL\n\n- The session_id is injected by the hook - use it directly\n- Always update the active boulder registry entry BEFORE starting work\n- If `worktree_path` is set in the active registry entry, all work happens inside that worktree directory\n- Read the FULL plan file before delegating any tasks\n- Follow guard delegation protocols (7-section format)\n\n## TASK BREAKDOWN (MANDATORY)\n\nAfter reading the plan file, you MUST decompose every plan task into granular, implementation-level sub-steps and register ALL of them as task/todo items BEFORE starting any work.\n\n**How to break down**:\n- Each plan checkbox item (e.g., `- [ ] Add user authentication`) must be split into concrete, actionable sub-tasks\n- Sub-tasks should be specific enough that each one touches a clear set of files/functions\n- Include: file to modify, what to change, expected behavior, and how to verify\n- Do NOT leave any task vague - \"implement feature X\" is NOT acceptable; \"add validateToken() to src/auth/middleware.ts that checks JWT expiry and returns 401\" IS acceptable\n\n**Example breakdown**:\nPlan task: `- [ ] Add rate limiting to API`\n\u2192 Todo items:\n  1. Create `src/middleware/rate-limiter.ts` with sliding window algorithm (max 100 req/min per IP)\n  2. Add RateLimiter middleware to `src/app.ts` router chain, before auth middleware\n  3. Add rate limit headers (X-RateLimit-Limit, X-RateLimit-Remaining) to response in `rate-limiter.ts`\n  4. Add test: verify 429 response after exceeding limit in `src/middleware/rate-limiter.test.ts`\n  5. Add test: verify headers are present on normal responses\n\nRegister these as task/todo items so progress is tracked and visible throughout the session.\n\n## WORKTREE COMPLETION\n\nWhen ALL plan tasks are complete:\n1. Commit remaining changes in the worktree\n2. The plugin auto-syncs `.bob/notepads/` back to the main repo\n3. The worktree is auto-removed via `git worktree remove`\n4. The plan is deregistered from `boulder-registry/`\n\nDo NOT manually copy `.bob/` -- the plugin handles this.\n\n## PARALLEL PLANS\n\nMultiple plans can run simultaneously. Each plan lives in its own git worktree\nat `.opencode/worktrees/<plan-name>/` for complete filesystem isolation.\n\n- Auto-worktree: created automatically when a second plan starts - no `--worktree` needed\n- Manual worktree: `--worktree <path>` overrides the default location\n- Registry: `.bob/boulder-registry/{plan-name}.json` tracks each plan independently\n- Stop-continuation: only affects the calling session's plan, not other active plans\n";

package/dist/features/builtin-skills/skills/interview-me.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinSkill } from "../types";
+export declare const interviewMeSkill: BuiltinSkill;

package/dist/features/builtin-skills/skills/planning-and-task-breakdown.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinSkill } from "../types";
+export declare const planningAndTaskBreakdownSkill: BuiltinSkill;

package/dist/hooks/reasoning-content-cache/hook.d.ts

@@ -0,0 +1,11 @@
+import type { Message, Part } from "@opencode-ai/sdk";
+interface MessageWithParts {
+    info: Message;
+    parts: Part[];
+}
+export declare function createReasoningContentCacheHook(): {
+    "experimental.chat.messages.transform": (input: Record<string, never>, output: {
+        messages: MessageWithParts[];
+    }) => Promise<void>;
+};
+export {};

package/dist/hooks/reasoning-content-cache/index.d.ts

@@ -0,0 +1 @@
+export { createReasoningContentCacheHook } from "./hook";

package/dist/hooks/session-recovery/checkpoint.d.ts

@@ -0,0 +1,48 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export interface RecoveryCheckpoint {
+    version: number;
+    sessionID: string;
+    timestamp: number;
+    phase: "pre_compaction" | "pre_tool_execution" | "pre_continuation" | "pre_model_switch";
+    context: {
+        agent?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+            variant?: string;
+        };
+        tools?: Record<string, boolean>;
+        messageCount?: number;
+    };
+}
+/**
+ * Creates a recovery checkpoint before error-prone operations.
+ * This allows the system to restore context if a subsequent operation fails.
+ */
+export declare class RecoveryCheckpointManager {
+    private checkpoints;
+    private backupDir;
+    constructor(ctx: PluginInput);
+    /**
+     * Create a checkpoint before an operation that could fail.
+     */
+    checkpoint(sessionID: string, phase: RecoveryCheckpoint["phase"], context?: RecoveryCheckpoint["context"]): Promise<void>;
+    /**
+     * Get the last checkpoint for a session.
+     */
+    getLastCheckpoint(sessionID: string): RecoveryCheckpoint | undefined;
+    /**
+     * Clear the checkpoint after successful operation completion.
+     */
+    clearCheckpoint(sessionID: string): void;
+    /**
+     * Check if a recent checkpoint exists for a session.
+     */
+    hasRecentCheckpoint(sessionID: string, maxAgeMs?: number): boolean;
+    private persistCheckpoint;
+    private deletePersistedCheckpoint;
+}
+/**
+ * Creates a recovery checkpoint manager.
+ */
+export declare function createRecoveryCheckpointManager(ctx: PluginInput): RecoveryCheckpointManager;

package/dist/hooks/session-recovery/enhanced-hook.d.ts

@@ -0,0 +1,30 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { SessionRecoveryHook, SessionRecoveryOptions } from "./hook";
+import { type SessionStateSnapshot } from "./state-backup";
+export interface EnhancedSessionRecoveryHook extends SessionRecoveryHook {
+    captureState: (sessionID: string, options?: CaptureOptions) => Promise<void>;
+    getSnapshot: (sessionID: string) => SessionStateSnapshot | undefined;
+    clearSnapshot: (sessionID: string) => void;
+}
+export interface CaptureOptions {
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+        variant?: string;
+    };
+    tools?: Record<string, boolean>;
+    todoSnapshot?: Array<{
+        id: string;
+        content: string;
+        status: string;
+    }>;
+    activePlanName?: string;
+    continuationState?: {
+        failureCount: number;
+        lastInjectedAt?: number;
+        stagnationCount: number;
+    };
+    sessionTitle?: string;
+}
+export declare function createSessionRecoveryHook(ctx: PluginInput, options?: SessionRecoveryOptions): EnhancedSessionRecoveryHook;

package/dist/hooks/session-recovery/state-backup.d.ts

@@ -0,0 +1,76 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export interface SessionStateSnapshot {
+    sessionID: string;
+    timestamp: number;
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+        variant?: string;
+    };
+    tools?: Record<string, boolean>;
+    todoSnapshot?: Array<{
+        id: string;
+        content: string;
+        status: string;
+    }>;
+    activePlanName?: string;
+    continuationState?: {
+        failureCount: number;
+        lastInjectedAt?: number;
+        stagnationCount: number;
+    };
+    sessionTitle?: string;
+}
+/**
+ * Manages durable session state backups for recovery scenarios.
+ * Snapshots are written to the filesystem so they survive process restarts.
+ */
+export declare class SessionStateBackupManager {
+    private snapshots;
+    private backupDir;
+    constructor(ctx: PluginInput);
+    /**
+     * Capture a comprehensive snapshot of the current session state.
+     * This is designed to be called before error-prone operations.
+     */
+    capture(sessionID: string, options?: {
+        agent?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+            variant?: string;
+        };
+        tools?: Record<string, boolean>;
+        todoSnapshot?: Array<{
+            id: string;
+            content: string;
+            status: string;
+        }>;
+        activePlanName?: string;
+        continuationState?: {
+            failureCount: number;
+            lastInjectedAt?: number;
+            stagnationCount: number;
+        };
+        sessionTitle?: string;
+    }): Promise<void>;
+    /**
+     * Retrieve a snapshot for a session if one exists.
+     */
+    getSnapshot(sessionID: string): SessionStateSnapshot | undefined;
+    /**
+     * Clear a snapshot after successful recovery or when no longer needed.
+     */
+    clearSnapshot(sessionID: string): void;
+    /**
+     * Check if a recent snapshot exists for a session.
+     */
+    hasRecentSnapshot(sessionID: string, maxAgeMs?: number): boolean;
+    private persistSnapshot;
+    private deletePersistedSnapshot;
+}
+/**
+ * Creates a session state backup manager for the plugin.
+ */
+export declare function createSessionStateBackupManager(ctx: PluginInput): SessionStateBackupManager;

package/dist/hooks/shared/compaction-in-progress.d.ts

@@ -0,0 +1,4 @@
+export declare function isCompacting(sessionID: string): boolean;
+export declare function markCompacting(sessionID: string): void;
+export declare function markCompactionDone(sessionID: string): void;
+export declare function clearSession(sessionID: string): void;

package/dist/hooks/start-work/git-operations.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Git Operations for Manager Source Control Integration (CH-007)
+ *
+ * Provides git utilities for branch tracking and divergence detection.
+ */
+/**
+ * Get the current git branch name for a directory
+ * @returns branch name or null if not a git repo
+ */
+export declare function getCurrentBranch(directory: string): string | null;
+/**
+ * Check if the current branch has diverged from its upstream
+ * Returns true if branch has diverged (both ahead and behind) or has unpulled commits
+ * @returns true if divergence detected
+ */
+export declare function hasUpstreamDivergence(directory: string): boolean;
+/**
+ * Get list of modified files compared to HEAD
+ * @returns array of relative file paths
+ */
+export declare function getModifiedFiles(directory: string): string[];
+/**
+ * Get list of staged files
+ * @returns array of relative file paths
+ */
+export declare function getStagedFiles(directory: string): string[];
+/**
+ * Check if there are uncommitted changes
+ * @returns true if there are uncommitted changes
+ */
+export declare function hasUncommittedChanges(directory: string): boolean;
+/**
+ * Run `git merge --no-commit` to check if a merge would succeed without committing
+ * This is used to check if the current branch can be merged into without conflicts
+ * @returns true if merge would succeed (no conflicts), false if there are conflicts
+ */
+export declare function canMergeWithoutConflicts(directory: string, targetBranch?: string): boolean;
+/**
+ * Get branch info for a directory including divergence status
+ * @returns branch info object
+ */
+export declare function getBranchInfo(directory: string): {
+    branch_name: string | null;
+    upstream_divergence: boolean;
+    modified_files: string[];
+    has_uncommitted: boolean;
+};

package/dist/hooks/token-budget.d.ts

@@ -0,0 +1,30 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import { type ContextLimitModelCacheState } from "../shared/context-limit-resolver";
+export interface TokenBudgetConfig {
+    warningThreshold80?: number;
+    warningThreshold90?: number;
+    hardLimitThreshold?: number;
+}
+export declare function createTokenBudgetHook(ctx: PluginInput, modelCacheState?: ContextLimitModelCacheState, config?: TokenBudgetConfig): {
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }) => Promise<void>;
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+    event: ({ event, }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+};
+export type TokenBudgetHook = ReturnType<typeof createTokenBudgetHook>;