opencode-hive 1.0.7 → 1.2.0

package/dist/background/poller.d.ts

@@ -1,131 +0,0 @@
-/**
- * Background Poller for session status and stability detection.
- *
- * This module provides READ-ONLY observation of background task sessions.
- * It does NOT write to .hive - only updates in-memory task progress.
- *
- * Capabilities:
- * - Track session status (running/idle)
- * - Track message growth and last activity timestamps
- * - Compute "maybe stuck" heuristics
- * - Exponential backoff to avoid polling storms
- */
-import { BackgroundTaskStore } from './store.js';
-import { OpencodeClient } from './types.js';
-/**
- * Configuration for the background poller.
- */
-export interface PollerConfig {
-    /** Base polling interval in ms (default: 5000) */
-    pollIntervalMs?: number;
-    /** Max polling interval with backoff (default: 30000) */
-    maxPollIntervalMs?: number;
-    /** Time before task is considered "maybe stuck" (default: 600000 = 10 min) */
-    stuckThresholdMs?: number;
-    /** Minimum runtime before stuck detection kicks in (default: 30000 = 30 sec) */
-    minRuntimeBeforeStuckMs?: number;
-    /** Consecutive stable polls before marking as stable (default: 3) */
-    stableCountThreshold?: number;
-}
-/**
- * Optional callbacks for reacting to observed session state.
- *
- * NOTE: Poller remains "read-only" with respect to `.hive`.
- * These callbacks are intended for in-memory lifecycle transitions (e.g. marking
- * a background task completed) handled by the owning manager.
- */
-export interface PollerHandlers {
-    /**
-     * Invoked when the poller observes that a background session is idle/complete.
-     *
-     * The owning manager should:
-     * - transition the task to a terminal state
-     * - release any concurrency slot
-     * - cleanup poller state
-     */
-    onSessionIdle?: (sessionId: string, reason: 'status' | 'stable') => void;
-}
-/**
- * Observation result for a single task.
- */
-export interface TaskObservation {
-    taskId: string;
-    sessionId: string;
-    status: string;
-    messageCount: number;
-    lastActivityAt: string | null;
-    maybeStuck: boolean;
-    stablePolls: number;
-    isStable: boolean;
-}
-/**
- * Background Poller - read-only observer for task sessions.
- *
- * IMPORTANT: This poller does NOT write to .hive.
- * It only updates in-memory task progress for status reporting.
- */
-export declare class BackgroundPoller {
-    private store;
-    private client;
-    private config;
-    private handlers;
-    private pollingState;
-    private pollInterval;
-    private isPolling;
-    private currentIntervalMs;
-    constructor(store: BackgroundTaskStore, client: OpencodeClient, config?: PollerConfig, handlers?: PollerHandlers);
-    /**
-     * Start the background poller.
-     * Automatically stops when no active tasks remain.
-     */
-    start(): void;
-    /**
-     * Stop the background poller.
-     */
-    stop(): void;
-    /**
-     * Check if poller is currently running.
-     */
-    isRunning(): boolean;
-    /**
-     * Get observations for all active tasks.
-     * This is a read-only snapshot of current state.
-     */
-    getObservations(): TaskObservation[];
-    /**
-     * Get observation for a specific task.
-     */
-    getTaskObservation(taskId: string): TaskObservation | null;
-    /**
-     * Perform a single poll cycle.
-     * Updates in-memory progress only - NO .hive writes.
-     */
-    poll(): Promise<void>;
-    /**
-     * Poll a single task and update its progress.
-     * READ-ONLY: Only updates in-memory store, never writes .hive.
-     */
-    private pollTask;
-    /**
-     * Build an observation from task and polling state.
-     */
-    private buildObservation;
-    /**
-     * Adjust polling interval based on activity patterns.
-     * Uses exponential backoff when tasks are stable.
-     */
-    private adjustPollingInterval;
-    /**
-     * Clean up polling state for a task.
-     * Call when task reaches terminal state.
-     */
-    cleanupTask(taskId: string): void;
-    /**
-     * Clear all state (for testing or shutdown).
-     */
-    clear(): void;
-}
-/**
- * Create a new BackgroundPoller instance.
- */
-export declare function createPoller(store: BackgroundTaskStore, client: OpencodeClient, config?: PollerConfig, handlers?: PollerHandlers): BackgroundPoller;

package/dist/background/store.d.ts

@@ -1,100 +0,0 @@
-/**
- * In-memory store for background task records.
- *
- * Provides:
- * - CRUD operations for task records
- * - Idempotency key lookups
- * - State machine enforcement
- * - Query methods for task filtering
- */
-import { BackgroundTaskRecord, BackgroundTaskStatus, BackgroundTaskProgress } from './types.js';
-/**
- * In-memory store for background tasks.
- * Thread-safe for single-process Node.js (no concurrent access issues).
- */
-export declare class BackgroundTaskStore {
-    private tasks;
-    private idempotencyIndex;
-    /**
-     * Create a new task record.
-     *
-     * @param options - Task creation options
-     * @returns The created task record
-     * @throws If idempotencyKey already exists (use getByIdempotencyKey first)
-     */
-    create(options: {
-        agent: string;
-        description: string;
-        sessionId: string;
-        idempotencyKey?: string;
-        parentSessionId?: string;
-        parentMessageId?: string;
-        parentAgent?: string;
-        notifyParent?: boolean;
-        hiveFeature?: string;
-        hiveTaskFolder?: string;
-        workdir?: string;
-    }): BackgroundTaskRecord;
-    /**
-     * Get a task by ID.
-     */
-    get(taskId: string): BackgroundTaskRecord | undefined;
-    /**
-     * Get a task by idempotency key.
-     */
-    getByIdempotencyKey(key: string): BackgroundTaskRecord | undefined;
-    /**
-     * Get a task by Hive feature and task folder.
-     */
-    getByHiveTask(feature: string, taskFolder: string): BackgroundTaskRecord | undefined;
-    /**
-     * Update task status with state machine enforcement.
-     *
-     * @param taskId - Task ID to update
-     * @param newStatus - New status
-     * @param updates - Additional field updates
-     * @returns Updated task record
-     * @throws If transition is invalid
-     */
-    updateStatus(taskId: string, newStatus: BackgroundTaskStatus, updates?: Partial<Pick<BackgroundTaskRecord, 'errorMessage' | 'progress'>>): BackgroundTaskRecord;
-    /**
-     * Update task progress without changing status.
-     */
-    updateProgress(taskId: string, progress: Partial<BackgroundTaskProgress>): BackgroundTaskRecord;
-    /**
-     * Delete a task.
-     */
-    delete(taskId: string): boolean;
-    /**
-     * List all tasks, optionally filtered.
-     */
-    list(filter?: {
-        status?: BackgroundTaskStatus | BackgroundTaskStatus[];
-        parentSessionId?: string;
-        hiveFeature?: string;
-    }): BackgroundTaskRecord[];
-    /**
-     * Get all active (non-terminal) tasks.
-     */
-    getActive(): BackgroundTaskRecord[];
-    /**
-     * Get task count by status.
-     */
-    countByStatus(): Record<BackgroundTaskStatus, number>;
-    /**
-     * Clear all tasks (for testing).
-     */
-    clear(): void;
-    /**
-     * Get total task count.
-     */
-    get size(): number;
-}
-/**
- * Get or create the global store instance.
- */
-export declare function getStore(): BackgroundTaskStore;
-/**
- * Reset the global store (for testing).
- */
-export declare function resetStore(): void;

package/dist/background/types.d.ts

@@ -1,246 +0,0 @@
-/**
- * Background tasking types for Hive worker execution.
- *
- * This module defines the core types for background task management,
- * state machine transitions, and integration with Hive task lifecycle.
- */
-/**
- * Background task status states.
- *
- * State machine:
- *   spawned -> pending -> running -> completed/error/cancelled
- *                                 -> blocked/failed (Hive-specific)
- *
- * - spawned: Task created, session not yet started
- * - pending: Waiting for concurrency slot
- * - running: Session active, work in progress
- * - completed: Session idle, work finished successfully
- * - error: Session errored or failed to start
- * - cancelled: Explicitly cancelled by user/system
- * - blocked: Worker reported blocker (Hive protocol)
- * - failed: Worker reported failure (Hive protocol)
- */
-export type BackgroundTaskStatus = 'spawned' | 'pending' | 'running' | 'completed' | 'error' | 'cancelled' | 'blocked' | 'failed';
-/**
- * Core background task record stored in memory.
- */
-export interface BackgroundTaskRecord {
-    /** Unique task ID (generated or user-provided) */
-    taskId: string;
-    /** OpenCode session ID for this task */
-    sessionId: string;
-    /** Agent type handling this task */
-    agent: string;
-    /** Human-readable description */
-    description: string;
-    /** Current status */
-    status: BackgroundTaskStatus;
-    /** Provider identity for multi-provider support */
-    provider: 'hive';
-    /** Idempotency key for safe retries */
-    idempotencyKey?: string;
-    /** ISO timestamp when task was created */
-    createdAt: string;
-    /** ISO timestamp when task started running */
-    startedAt?: string;
-    /** ISO timestamp when task completed/failed/cancelled */
-    completedAt?: string;
-    /** ISO timestamp of last activity */
-    lastActiveAt?: string;
-    /** Parent session ID (orchestrator session) */
-    parentSessionId?: string;
-    /** Parent message ID */
-    parentMessageId?: string;
-    /** Parent agent name (used for completion notifications) */
-    parentAgent?: string;
-    /** Whether to notify the parent session when this task reaches terminal state */
-    notifyParent?: boolean;
-    /** Hive feature name (if Hive-linked) */
-    hiveFeature?: string;
-    /** Hive task folder (if Hive-linked) */
-    hiveTaskFolder?: string;
-    /** Working directory for task execution */
-    workdir?: string;
-    /** Error message if status is error */
-    errorMessage?: string;
-    /** Progress tracking */
-    progress?: BackgroundTaskProgress;
-}
-/**
- * Progress tracking for a background task.
- */
-export interface BackgroundTaskProgress {
-    /** Number of tool calls made */
-    toolCalls?: number;
-    /** Last tool used */
-    lastTool?: string;
-    /** Last message content (truncated) */
-    lastMessage?: string;
-    /** ISO timestamp of last message */
-    lastMessageAt?: string;
-    /** Number of messages in session */
-    messageCount?: number;
-}
-/**
- * Options for spawning a new background task.
- */
-export interface SpawnOptions {
-    /** Agent type to use */
-    agent: string;
-    /** Task prompt/instructions */
-    prompt: string;
-    /** Human-readable description */
-    description: string;
-    /** Idempotency key for safe retries */
-    idempotencyKey?: string;
-    /** Working directory for task execution */
-    workdir?: string;
-    /** Parent session ID (orchestrator session) */
-    parentSessionId?: string;
-    /** Parent message ID */
-    parentMessageId?: string;
-    /** Parent agent name (used for completion notifications) */
-    parentAgent?: string;
-    /** Whether to notify parent session on terminal state (default: true for sync=false) */
-    notifyParent?: boolean;
-    /** Hive feature name (if Hive-linked) */
-    hiveFeature?: string;
-    /** Hive task folder (if Hive-linked) */
-    hiveTaskFolder?: string;
-    /** Whether to wait for completion (sync mode) */
-    sync?: boolean;
-    /**
-     * Hive attempt number for this run.
-     * Used only for Hive-linked tasks to persist workerSession.attempt correctly.
-     */
-    attempt?: number;
-    /**
-     * Model variant key to apply to the background task prompt.
-     * This is passed to OpenCode's session.prompt body and merged with
-     * model.variants[variantKey] into provider options.
-     */
-    variant?: string;
-}
-/**
- * Result of a spawn operation.
- */
-export interface SpawnResult {
-    /** The created/existing task record */
-    task: BackgroundTaskRecord;
-    /** Whether an existing task was returned (idempotency hit) */
-    wasExisting: boolean;
-    /** Error message if spawn failed */
-    error?: string;
-}
-/**
- * Valid state transitions for the background task state machine.
- */
-export declare const VALID_TRANSITIONS: Record<BackgroundTaskStatus, BackgroundTaskStatus[]>;
-/**
- * Check if a status is terminal (no further transitions possible).
- */
-export declare function isTerminalStatus(status: BackgroundTaskStatus): boolean;
-/**
- * Check if a transition is valid.
- */
-export declare function isValidTransition(from: BackgroundTaskStatus, to: BackgroundTaskStatus): boolean;
-/**
- * OpenCode client interface (minimal subset needed for background tasks).
- * This allows stubbing in tests without importing the full SDK.
- */
-export interface OpencodeClient {
-    session: {
-        create(options: {
-            body: {
-                title?: string;
-                parentID?: string;
-            };
-        }): Promise<{
-            data?: {
-                id?: string;
-            };
-        }>;
-        prompt(options: {
-            path: {
-                id: string;
-            };
-            body: {
-                agent?: string;
-                parts: Array<{
-                    type: string;
-                    text: string;
-                }>;
-                tools?: Record<string, boolean>;
-                variant?: string;
-            };
-        }): Promise<{
-            data?: unknown;
-        }>;
-        get(options: {
-            path: {
-                id: string;
-            };
-        }): Promise<{
-            data?: {
-                id?: string;
-                status?: string;
-                parentID?: string;
-            };
-        }>;
-        messages(options: {
-            path: {
-                id: string;
-            };
-        }): Promise<{
-            data?: unknown[];
-        }>;
-        abort(options: {
-            path: {
-                id: string;
-            };
-        }): Promise<void>;
-        /** Get status of all sessions (optional - may not exist on all clients) */
-        status?(): Promise<{
-            data?: Record<string, {
-                type: string;
-            }>;
-        }>;
-    };
-    app: {
-        agents(options: Record<string, unknown>): Promise<{
-            data?: Array<{
-                name: string;
-                description?: string;
-                mode?: string;
-            }>;
-        }>;
-        log(options: {
-            body: {
-                service: string;
-                level: string;
-                message: string;
-            };
-        }): Promise<void>;
-    };
-    config: {
-        get(): Promise<{
-            data?: Record<string, unknown>;
-        }>;
-    };
-}
-/**
- * Agent info from OpenCode registry.
- */
-export interface AgentInfo {
-    name: string;
-    description?: string;
-    mode?: string;
-}
-/**
- * Result of agent validation.
- */
-export interface AgentValidationResult {
-    valid: boolean;
-    error?: string;
-    agent?: AgentInfo;
-}

package/dist/tools/background-tools.d.ts

@@ -1,37 +0,0 @@
-/**
- * Background task tools for Hive worker delegation.
- *
- * Provides user-facing tools for spawning, monitoring, and cancelling
- * background tasks that execute in separate OpenCode sessions.
- *
- * Tools:
- * - hive_background_task: Spawn a new background task
- * - hive_background_output: Get output from a running/completed task
- * - hive_background_cancel: Cancel running task(s)
- */
-import { type ToolDefinition } from '@opencode-ai/plugin';
-import { type ConfigService } from 'hive-core';
-import { BackgroundManager, type OpencodeClient } from '../background/index.js';
-/**
- * Options for creating background tools.
- */
-export interface BackgroundToolsOptions {
-    /** The BackgroundManager instance for task lifecycle */
-    manager: BackgroundManager;
-    /** OpenCode client for session operations */
-    client: OpencodeClient;
-    /** Optional ConfigService for resolving per-agent variants */
-    configService?: ConfigService;
-}
-/**
- * Create background task tools.
- *
- * @param manager - The BackgroundManager instance for task lifecycle
- * @param client - OpenCode client for session operations
- * @param configService - Optional ConfigService for resolving per-agent variants
- */
-export declare function createBackgroundTools(manager: BackgroundManager, client: OpencodeClient, configService?: ConfigService): {
-    hive_background_task: ToolDefinition;
-    hive_background_output: ToolDefinition;
-    hive_background_cancel: ToolDefinition;
-};

package/skills/onboarding/SKILL.md

@@ -1,61 +0,0 @@
----
-name: onboarding
-description: "Ask about workflow preferences and store them in .hive/contexts/preferences.md before proceeding."
----
-
-# Onboarding Preferences
-
-## Overview
-
-Gather workflow preferences so the assistant can match the user's desired working style.
-
-## When to Ask
-
-- **Immediately when the skill is loaded**, before any other work.
-- If `.hive/contexts/preferences.md` does not exist, start onboarding.
-- If later a decision is ambiguous and preferences are missing, ask again.
-
-## Preference Storage
-
-Use `hive_context_write` to write `.hive/contexts/preferences.md` with this exact template:
-
-```
-# Preferences
-
-## Exploration Style
-sync
-
-## Research Depth
-medium
-
-## Confirmation Level
-standard
-
-## Commit Behavior
-ask-before-commit
-```
-
-## If Preferences Already Exist
-
-Follow the same pattern used in `packages/vscode-hive/src/tools/plan.ts`:
-
-1. Use `contextService.list(feature)` to detect existing contexts.
-2. Ask **"Preferences already exist. Keep or overwrite?"** using the `question()` tool.
-3. If keep → continue using existing preferences.
-4. If overwrite → collect new answers and write them with `hive_context_write`.
-
-## Questions to Ask (Always use `question()`)
-
-Ask one at a time, with the provided options. Store the answers in `.hive/contexts/preferences.md`.
-
-1. **Exploration Style:** sync | async
-2. **Research Depth:** shallow | medium | deep
-3. **Confirmation Level:** minimal | standard | high
-4. **Commit Behavior:** ask-before-commit | auto-commit | never-commit
-
-## Requirements
-
-- Use the `question()` tool (no plain text questions).
-- Ask immediately when the skill loads if preferences are missing.
-- If later a decision is ambiguous and preferences are missing, ask again.
-- Always store answers using `hive_context_write` with the template above.