opencode-hive 1.3.4 → 1.3.6

package/README.md

@@ -66,8 +66,8 @@ During planning, "don't execute" means "don't implement" (no code edits, no work
 ### Tasks
 | Tool | Description |
 |------|-------------|
-| `hive_tasks_sync` | Generate tasks from plan |
-| `hive_task_create` | Create manual task |
+| `hive_tasks_sync` | Generate tasks from plan, or rewrite pending plan tasks with `refreshPending: true` after a plan amendment |
+| `hive_task_create` | Create a manual task with explicit `dependsOn` and optional structured metadata |
 | `hive_task_update` | Update task status/summary |
 
 ### Worktree
@@ -108,6 +108,43 @@ When using Dynamic Context Pruning (DCP), use a Hive-safe config in `~/.config/o
 
 For local plugin testing, keep OpenCode plugin entry as `"opencode-hive"` (not `"opencode-hive@latest"`).
 
+#### Compaction recovery and session re-anchoring
+
+OpenCode can compact long sessions. When that happens mid-orchestration or mid-task, Hive needs the session to recover its role and task boundaries without re-reading the whole repository.
+
+The plugin now persists durable session metadata and uses it during `experimental.session.compacting` to rebuild a compact re-anchor prompt.
+
+Where:
+
+- Global session state is written to `.hive/sessions.json`.
+- Feature-local mirrors are written to `.hive/features/<feature>/sessions.json`.
+- Session classification distinguishes `primary`, `subagent`, `task-worker`, and `unknown`.
+- Primary and subagent recovery can replay the stored user directive once after compaction.
+- Task-worker recovery uses the strict re-anchor plus one bounded worker-specific synthetic replay after compaction.
+- The task-worker replay can reference `.hive/features/<feature>/tasks/<task>/worker-prompt.md`.
+
+Task-worker recovery is intentionally strict:
+
+- keep the same role
+- do not delegate
+- do not re-read the full codebase
+- re-read `worker-prompt.md`
+- finish only the current task assignment
+- do not merge
+- do not start the next task
+- do not use orchestration tools unless the worker prompt explicitly says so
+- continue from the last known point
+
+This split is deliberate: primary and subagent sessions replay the stored user directive once after compaction, while task-workers also receive one worker-specific synthetic replay after compaction that restates the active task identity and worker boundaries.
+
+Manual tasks follow the same DAG model as plan-backed tasks:
+
+- `hive_task_create()` stores manual tasks with explicit `dependsOn` metadata instead of inferring sequential order.
+- Structured manual-task fields such as `goal`, `description`, `acceptanceCriteria`, `files`, and `references` are turned into worker-facing `spec.md` content.
+- If review feedback changes downstream sequencing or scope, update `plan.md` and run `hive_tasks_sync({ refreshPending: true })` so pending plan tasks pick up the new `dependsOn` graph and regenerated specs.
+
+This recovery path applies to the built-in `forager-worker` and custom agents derived from it, because they are the sessions most likely to be compacted mid-implementation.
+
 ## Prompt Budgeting & Observability
 
 Hive automatically bounds worker prompt sizes to prevent context overflow and tool output truncation.
@@ -136,6 +173,8 @@ When limits are exceeded, content is truncated with `...[truncated]` markers and
 
 Large prompts are written to `.hive/features/<feature>/tasks/<task>/worker-prompt.md` and passed by file reference (`workerPromptPath`) rather than inlined in tool output. This prevents truncation of large prompts.
 
+That same `worker-prompt.md` path is also reused during compaction recovery so task workers can re-anchor to the exact task assignment after a compacted session resumes.
+
 ## Plan Format
 
 ```markdown
@@ -359,6 +398,13 @@ ID guardrails:
 - plugin-reserved aliases are blocked (`hive`, `architect`, `swarm`, `scout`, `forager`, `hygienic`, `receiver`)
 - operational IDs are blocked (`build`, `plan`, `code`)
 
+Compaction classification follows the base agent:
+
+- `forager-worker` derivatives are treated as `task-worker`
+- `hygienic-reviewer` derivatives are treated as `subagent`
+
+This ensures custom workers recover with the same execution constraints as their base role.
+
 ### Custom Models
 
 Override models for specific agents:

package/dist/hive-core/src/services/index.d.ts

@@ -1,6 +1,7 @@
 export { FeatureService } from './featureService.js';
 export { PlanService } from './planService.js';
 export { TaskService } from './taskService.js';
+export type { SyncOptions } from './taskService.js';
 export { SubtaskService } from './subtaskService.js';
 export { WorktreeService, createWorktreeService } from './worktreeService.js';
 export type { WorktreeInfo, DiffResult, ApplyResult, CommitResult, MergeResult, WorktreeConfig } from './worktreeService.js';

package/dist/hive-core/src/services/sessionService.d.ts

@@ -1,10 +1,17 @@
-import { SessionInfo } from '../types.js';
+import type { SessionInfo } from '../types.js';
 export declare class SessionService {
     private projectRoot;
     constructor(projectRoot: string);
+    private applySessionPatch;
     private getSessionsPath;
     private getSessions;
     private saveSessions;
+    private getGlobalSessions;
+    private saveGlobalSessions;
+    private updateGlobalSessions;
+    trackGlobal(sessionId: string, patch?: Partial<SessionInfo>): SessionInfo;
+    bindFeature(sessionId: string, featureName: string, patch?: Partial<SessionInfo>): SessionInfo;
+    getGlobal(sessionId: string): SessionInfo | undefined;
     track(featureName: string, sessionId: string, taskFolder?: string): SessionInfo;
     setMaster(featureName: string, sessionId: string): void;
     getMaster(featureName: string): string | undefined;

package/dist/hive-core/src/services/taskService.d.ts

@@ -1,5 +1,5 @@
 import { LockOptions } from '../utils/paths.js';
-import { TaskStatus, TaskStatusType, TasksSyncResult, TaskInfo, Subtask, SubtaskType, WorkerSession } from '../types.js';
+import { TaskStatus, TaskStatusType, TasksSyncResult, TaskInfo, Subtask, SubtaskType, WorkerSession, ManualTaskMetadata } from '../types.js';
 /** Current schema version for TaskStatus */
 export declare const TASK_STATUS_SCHEMA_VERSION = 1;
 /** Fields that can be updated by background workers without clobbering completion-owned fields */
@@ -13,17 +13,21 @@ export interface CompletionFields {
     summary?: string;
     completedAt?: string;
 }
+export interface SyncOptions {
+    refreshPending?: boolean;
+}
 export declare class TaskService {
     private projectRoot;
     constructor(projectRoot: string);
-    sync(featureName: string): TasksSyncResult;
+    sync(featureName: string, options?: SyncOptions): TasksSyncResult;
     /**
      * Create a manual task with auto-incrementing index.
      * Folder format: "01-task-name", "02-task-name", etc.
      * Index ensures alphabetical sort = chronological order.
      */
-    create(featureName: string, name: string, order?: number): string;
+    create(featureName: string, name: string, order?: number, metadata?: ManualTaskMetadata): string;
     private createFromPlan;
+    private refreshPendingTask;
     buildSpecContent(params: {
         featureName: string;
         task: {
@@ -72,6 +76,7 @@ export declare class TaskService {
      */
     private detectCycles;
     writeSpec(featureName: string, taskFolder: string, content: string): string;
+    readSpec(featureName: string, taskFolder: string): string | null;
     /**
      * Update task status with locked atomic write.
      * Uses file locking to prevent race conditions between concurrent updates.
@@ -120,5 +125,6 @@ export declare class TaskService {
     readSubtaskReport(featureName: string, taskFolder: string, subtaskId: string): string | null;
     private listSubtaskFolders;
     private findSubtaskFolder;
+    private buildManualTaskSpec;
     private slugify;
 }

package/dist/hive-core/src/types.d.ts

@@ -50,6 +50,16 @@ export interface WorkerSession {
     /** Number of messages exchanged in session */
     messageCount?: number;
 }
+export interface ManualTaskMetadata {
+    goal?: string;
+    description?: string;
+    acceptanceCriteria?: string[];
+    references?: string[];
+    files?: string[];
+    reason?: string;
+    source?: 'review' | 'operator' | 'ad_hoc';
+    dependsOn?: string[];
+}
 export interface TaskStatus {
     /** Schema version for forward compatibility (default: 1) */
     schemaVersion?: number;
@@ -71,6 +81,8 @@ export interface TaskStatus {
      * Resolved from plan.md dependency annotations during hive_tasks_sync.
      */
     dependsOn?: string[];
+    /** Structured metadata for manual tasks */
+    metadata?: ManualTaskMetadata;
 }
 export type ReviewDocument = 'plan' | 'overview';
 export interface ReviewThread {
@@ -120,9 +132,17 @@ export interface ContextFile {
     content: string;
     updatedAt: string;
 }
+export type SessionKind = 'primary' | 'subagent' | 'task-worker' | 'unknown';
 export interface SessionInfo {
     sessionId: string;
+    featureName?: string;
     taskFolder?: string;
+    agent?: string;
+    baseAgent?: string;
+    sessionKind?: SessionKind;
+    workerPromptPath?: string;
+    directivePrompt?: string;
+    replayDirectivePending?: boolean;
     startedAt: string;
     lastActiveAt: string;
     messageCount?: number;

package/dist/hive-core/src/utils/paths.d.ts

@@ -3,6 +3,7 @@ export declare function normalizePath(filePath: string): string;
 export declare function getHivePath(projectRoot: string): string;
 export declare function getFeaturesPath(projectRoot: string): string;
 export declare function getActiveFeaturePath(projectRoot: string): string;
+export declare function getGlobalSessionsPath(projectRoot: string): string;
 export declare function listFeatureDirectories(projectRoot: string): FeatureDirectoryInfo[];
 export declare function resolveFeatureDirectoryName(projectRoot: string, featureName: string): string;
 export declare function getNextIndexedFeatureDirectoryName(projectRoot: string, featureName: string): string;