opencode-hive 1.3.3 → 1.3.5

package/README.md

@@ -108,6 +108,32 @@ 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.
+- For task workers, the re-anchor context can include `.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`
+- continue from the last known point
+
+This split is deliberate: post-compaction replay is for primary/subagent intent, while task-worker recovery comes from durable worktree context plus `worker-prompt.md` so implementation sessions stay attached to the exact task contract.
+
+This matters most for `forager-worker` and forager-derived custom agents, 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 +162,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 +387,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/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/types.d.ts

@@ -120,9 +120,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;

package/dist/index.js

@@ -871,8 +871,8 @@ var require_dist2 = __commonJS((exports) => {
 });
 
 // src/index.ts
-import * as path10 from "path";
-import * as fs12 from "fs";
+import * as path11 from "path";
+import * as fs13 from "fs";
 import * as os from "os";
 
 // ../../node_modules/zod/v4/classic/external.js
@@ -16738,6 +16738,9 @@ function getFeaturesPath(projectRoot) {
 function getActiveFeaturePath(projectRoot) {
   return path2.join(getHivePath(projectRoot), ACTIVE_FEATURE_FILE);
 }
+function getGlobalSessionsPath(projectRoot) {
+  return path2.join(getHivePath(projectRoot), "sessions.json");
+}
 function parseIndexedFeatureDirectoryName(directoryName) {
   const match = directoryName.match(/^(\d+)[_-](.+)$/);
   if (!match) {
@@ -22431,17 +22434,217 @@ ${f.content}`);
     return `${normalized}.md`;
   }
 }
-// ../hive-core/src/services/configService.ts
+// ../hive-core/src/services/sessionService.ts
 import * as fs9 from "fs";
 import * as path7 from "path";
+class SessionService {
+  projectRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  applySessionPatch(target, patch) {
+    if (!patch) {
+      return;
+    }
+    const { sessionId: _sessionId, ...rest } = patch;
+    Object.assign(target, rest);
+  }
+  getSessionsPath(featureName) {
+    return path7.join(getFeaturePath(this.projectRoot, featureName), "sessions.json");
+  }
+  getSessions(featureName) {
+    const sessionsPath = this.getSessionsPath(featureName);
+    return readJson(sessionsPath) || { sessions: [] };
+  }
+  saveSessions(featureName, data) {
+    const sessionsPath = this.getSessionsPath(featureName);
+    ensureDir(path7.dirname(sessionsPath));
+    writeJson(sessionsPath, data);
+  }
+  getGlobalSessions() {
+    const globalPath = getGlobalSessionsPath(this.projectRoot);
+    return readJson(globalPath) || { sessions: [] };
+  }
+  saveGlobalSessions(data) {
+    const globalPath = getGlobalSessionsPath(this.projectRoot);
+    ensureDir(path7.dirname(globalPath));
+    writeJson(globalPath, data);
+  }
+  updateGlobalSessions(mutator) {
+    const globalPath = getGlobalSessionsPath(this.projectRoot);
+    ensureDir(path7.dirname(globalPath));
+    const release = acquireLockSync(globalPath);
+    try {
+      const data = readJson(globalPath) || { sessions: [] };
+      const session = mutator(data);
+      writeJsonAtomic(globalPath, data);
+      return session;
+    } finally {
+      release();
+    }
+  }
+  trackGlobal(sessionId, patch) {
+    return this.updateGlobalSessions((data) => {
+      const now = new Date().toISOString();
+      let session = data.sessions.find((s) => s.sessionId === sessionId);
+      if (session) {
+        session.lastActiveAt = now;
+        this.applySessionPatch(session, patch);
+      } else {
+        session = {
+          sessionId,
+          startedAt: now,
+          lastActiveAt: now
+        };
+        this.applySessionPatch(session, patch);
+        data.sessions.push(session);
+      }
+      return session;
+    });
+  }
+  bindFeature(sessionId, featureName, patch) {
+    const session = this.updateGlobalSessions((data) => {
+      let current = data.sessions.find((s) => s.sessionId === sessionId);
+      const now = new Date().toISOString();
+      if (!current) {
+        current = {
+          sessionId,
+          startedAt: now,
+          lastActiveAt: now
+        };
+        data.sessions.push(current);
+      }
+      current.featureName = featureName;
+      current.lastActiveAt = now;
+      this.applySessionPatch(current, patch);
+      return current;
+    });
+    const featureData = this.getSessions(featureName);
+    let featureSession = featureData.sessions.find((s) => s.sessionId === sessionId);
+    if (featureSession) {
+      Object.assign(featureSession, session);
+    } else {
+      featureData.sessions.push({ ...session });
+    }
+    this.saveSessions(featureName, featureData);
+    return session;
+  }
+  getGlobal(sessionId) {
+    const data = this.getGlobalSessions();
+    return data.sessions.find((s) => s.sessionId === sessionId);
+  }
+  track(featureName, sessionId, taskFolder) {
+    const data = this.getSessions(featureName);
+    const now = new Date().toISOString();
+    let session = data.sessions.find((s) => s.sessionId === sessionId);
+    if (session) {
+      session.lastActiveAt = now;
+      if (taskFolder)
+        session.taskFolder = taskFolder;
+    } else {
+      session = {
+        sessionId,
+        taskFolder,
+        startedAt: now,
+        lastActiveAt: now
+      };
+      data.sessions.push(session);
+    }
+    if (!data.master) {
+      data.master = sessionId;
+    }
+    this.saveSessions(featureName, data);
+    return session;
+  }
+  setMaster(featureName, sessionId) {
+    const data = this.getSessions(featureName);
+    data.master = sessionId;
+    this.saveSessions(featureName, data);
+  }
+  getMaster(featureName) {
+    return this.getSessions(featureName).master;
+  }
+  list(featureName) {
+    return this.getSessions(featureName).sessions;
+  }
+  get(featureName, sessionId) {
+    return this.getSessions(featureName).sessions.find((s) => s.sessionId === sessionId);
+  }
+  getByTask(featureName, taskFolder) {
+    return this.getSessions(featureName).sessions.find((s) => s.taskFolder === taskFolder);
+  }
+  remove(featureName, sessionId) {
+    const data = this.getSessions(featureName);
+    const index = data.sessions.findIndex((s) => s.sessionId === sessionId);
+    if (index === -1)
+      return false;
+    data.sessions.splice(index, 1);
+    if (data.master === sessionId) {
+      data.master = data.sessions[0]?.sessionId;
+    }
+    this.saveSessions(featureName, data);
+    return true;
+  }
+  findFeatureBySession(sessionId) {
+    const globalSession = this.getGlobal(sessionId);
+    if (globalSession?.featureName) {
+      return globalSession.featureName;
+    }
+    const featuresPath = path7.join(this.projectRoot, ".hive", "features");
+    if (!fs9.existsSync(featuresPath))
+      return null;
+    const features = fs9.readdirSync(featuresPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    for (const feature of features) {
+      const sessions = this.getSessions(feature);
+      if (sessions.sessions.some((s) => s.sessionId === sessionId)) {
+        return feature;
+      }
+      if (sessions.master === sessionId) {
+        return feature;
+      }
+    }
+    return null;
+  }
+  fork(featureName, fromSessionId) {
+    const data = this.getSessions(featureName);
+    const now = new Date().toISOString();
+    const sourceSession = fromSessionId ? data.sessions.find((s) => s.sessionId === fromSessionId) : data.sessions.find((s) => s.sessionId === data.master);
+    const newSessionId = `ses_fork_${Date.now()}`;
+    const newSession = {
+      sessionId: newSessionId,
+      taskFolder: sourceSession?.taskFolder,
+      startedAt: now,
+      lastActiveAt: now
+    };
+    data.sessions.push(newSession);
+    this.saveSessions(featureName, data);
+    return newSession;
+  }
+  fresh(featureName, title) {
+    const data = this.getSessions(featureName);
+    const now = new Date().toISOString();
+    const newSessionId = `ses_${title ? title.replace(/\s+/g, "_").toLowerCase() : Date.now()}`;
+    const newSession = {
+      sessionId: newSessionId,
+      startedAt: now,
+      lastActiveAt: now
+    };
+    data.sessions.push(newSession);
+    this.saveSessions(featureName, data);
+    return newSession;
+  }
+}
+// ../hive-core/src/services/configService.ts
+import * as fs10 from "fs";
+import * as path8 from "path";
 class ConfigService {
   configPath;
   cachedConfig = null;
   cachedCustomAgentConfigs = null;
   constructor() {
     const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-    const configDir = path7.join(homeDir, ".config", "opencode");
-    this.configPath = path7.join(configDir, "agent_hive.json");
+    const configDir = path8.join(homeDir, ".config", "opencode");
+    this.configPath = path8.join(configDir, "agent_hive.json");
   }
   getPath() {
     return this.configPath;
@@ -22451,12 +22654,12 @@ class ConfigService {
       return this.cachedConfig;
     }
     try {
-      if (!fs9.existsSync(this.configPath)) {
+      if (!fs10.existsSync(this.configPath)) {
         this.cachedConfig = { ...DEFAULT_HIVE_CONFIG };
         this.cachedCustomAgentConfigs = null;
         return this.cachedConfig;
       }
-      const raw = fs9.readFileSync(this.configPath, "utf-8");
+      const raw = fs10.readFileSync(this.configPath, "utf-8");
       const stored = JSON.parse(raw);
       const storedCustomAgents = this.isObjectRecord(stored.customAgents) ? stored.customAgents : {};
       const mergedBuiltInAgents = BUILT_IN_AGENT_NAMES.reduce((acc, agentName) => {
@@ -22504,17 +22707,17 @@ class ConfigService {
         ...updates.customAgents
       } : current.customAgents
     };
-    const configDir = path7.dirname(this.configPath);
-    if (!fs9.existsSync(configDir)) {
-      fs9.mkdirSync(configDir, { recursive: true });
+    const configDir = path8.dirname(this.configPath);
+    if (!fs10.existsSync(configDir)) {
+      fs10.mkdirSync(configDir, { recursive: true });
     }
-    fs9.writeFileSync(this.configPath, JSON.stringify(merged, null, 2));
+    fs10.writeFileSync(this.configPath, JSON.stringify(merged, null, 2));
     this.cachedConfig = merged;
     this.cachedCustomAgentConfigs = null;
     return merged;
   }
   exists() {
-    return fs9.existsSync(this.configPath);
+    return fs10.existsSync(this.configPath);
   }
   init() {
     if (!this.exists()) {
@@ -22650,8 +22853,8 @@ class ConfigService {
   }
 }
 // ../hive-core/src/services/agentsMdService.ts
-import * as fs10 from "fs";
-import * as path8 from "path";
+import * as fs11 from "fs";
+import * as path9 from "path";
 class AgentsMdService {
   rootDir;
   contextService;
@@ -22660,7 +22863,7 @@ class AgentsMdService {
     this.contextService = contextService;
   }
   async init() {
-    const agentsMdPath = path8.join(this.rootDir, "AGENTS.md");
+    const agentsMdPath = path9.join(this.rootDir, "AGENTS.md");
     const existed = fileExists(agentsMdPath);
     if (existed) {
       const existing = readText(agentsMdPath);
@@ -22671,14 +22874,14 @@ class AgentsMdService {
   }
   async sync(featureName) {
     const contexts = this.contextService.list(featureName);
-    const agentsMdPath = path8.join(this.rootDir, "AGENTS.md");
-    const current = await fs10.promises.readFile(agentsMdPath, "utf-8").catch(() => "");
+    const agentsMdPath = path9.join(this.rootDir, "AGENTS.md");
+    const current = await fs11.promises.readFile(agentsMdPath, "utf-8").catch(() => "");
     const findings = this.extractFindings(contexts);
     const proposals = this.generateProposals(findings, current);
     return { proposals, diff: this.formatDiff(current, proposals) };
   }
   apply(content) {
-    const agentsMdPath = path8.join(this.rootDir, "AGENTS.md");
+    const agentsMdPath = path9.join(this.rootDir, "AGENTS.md");
     const isNew = !fileExists(agentsMdPath);
     writeText(agentsMdPath, content);
     return { path: agentsMdPath, chars: content.length, isNew };
@@ -22738,7 +22941,7 @@ class AgentsMdService {
     return this.generateTemplate(detections);
   }
   async detectProjectInfo() {
-    const packageJsonPath = path8.join(this.rootDir, "package.json");
+    const packageJsonPath = path9.join(this.rootDir, "package.json");
     let packageJson = null;
     if (fileExists(packageJsonPath)) {
       try {
@@ -22758,26 +22961,26 @@ class AgentsMdService {
     return info;
   }
   detectPackageManager() {
-    if (fileExists(path8.join(this.rootDir, "bun.lockb")))
+    if (fileExists(path9.join(this.rootDir, "bun.lockb")))
       return "bun";
-    if (fileExists(path8.join(this.rootDir, "pnpm-lock.yaml")))
+    if (fileExists(path9.join(this.rootDir, "pnpm-lock.yaml")))
       return "pnpm";
-    if (fileExists(path8.join(this.rootDir, "yarn.lock")))
+    if (fileExists(path9.join(this.rootDir, "yarn.lock")))
       return "yarn";
-    if (fileExists(path8.join(this.rootDir, "package-lock.json")))
+    if (fileExists(path9.join(this.rootDir, "package-lock.json")))
       return "npm";
     return "npm";
   }
   detectLanguage() {
-    if (fileExists(path8.join(this.rootDir, "tsconfig.json")))
+    if (fileExists(path9.join(this.rootDir, "tsconfig.json")))
       return "TypeScript";
-    if (fileExists(path8.join(this.rootDir, "package.json")))
+    if (fileExists(path9.join(this.rootDir, "package.json")))
       return "JavaScript";
-    if (fileExists(path8.join(this.rootDir, "requirements.txt")))
+    if (fileExists(path9.join(this.rootDir, "requirements.txt")))
       return "Python";
-    if (fileExists(path8.join(this.rootDir, "go.mod")))
+    if (fileExists(path9.join(this.rootDir, "go.mod")))
       return "Go";
-    if (fileExists(path8.join(this.rootDir, "Cargo.toml")))
+    if (fileExists(path9.join(this.rootDir, "Cargo.toml")))
       return "Rust";
     return "Unknown";
   }
@@ -22856,25 +23059,25 @@ class AgentsMdService {
   }
 }
 // ../hive-core/src/services/dockerSandboxService.ts
-import { existsSync as existsSync4 } from "fs";
-import { join as join9, sep } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { join as join10, sep } from "path";
 import { execSync } from "child_process";
 
 class DockerSandboxService {
   static detectImage(worktreePath) {
-    if (existsSync4(join9(worktreePath, "Dockerfile"))) {
+    if (existsSync5(join10(worktreePath, "Dockerfile"))) {
       return null;
     }
-    if (existsSync4(join9(worktreePath, "package.json"))) {
+    if (existsSync5(join10(worktreePath, "package.json"))) {
       return "node:22-slim";
     }
-    if (existsSync4(join9(worktreePath, "requirements.txt")) || existsSync4(join9(worktreePath, "pyproject.toml"))) {
+    if (existsSync5(join10(worktreePath, "requirements.txt")) || existsSync5(join10(worktreePath, "pyproject.toml"))) {
       return "python:3.12-slim";
     }
-    if (existsSync4(join9(worktreePath, "go.mod"))) {
+    if (existsSync5(join10(worktreePath, "go.mod"))) {
       return "golang:1.22-slim";
     }
-    if (existsSync4(join9(worktreePath, "Cargo.toml"))) {
+    if (existsSync5(join10(worktreePath, "Cargo.toml"))) {
       return "rust:1.77-slim";
     }
     return "ubuntu:24.04";
@@ -23444,17 +23647,17 @@ function applyContextBudget(files, config2 = {}) {
 }
 
 // src/utils/prompt-file.ts
-import * as fs11 from "fs";
-import * as path9 from "path";
+import * as fs12 from "fs";
+import * as path10 from "path";
 function writeWorkerPromptFile(feature, task, prompt, hiveDir) {
-  const projectRoot = path9.dirname(hiveDir);
+  const projectRoot = path10.dirname(hiveDir);
   const featureDir = resolveFeatureDirectoryName(projectRoot, feature);
-  const promptDir = path9.join(hiveDir, "features", featureDir, "tasks", task);
-  const promptPath = path9.join(promptDir, "worker-prompt.md");
-  if (!fs11.existsSync(promptDir)) {
-    fs11.mkdirSync(promptDir, { recursive: true });
+  const promptDir = path10.join(hiveDir, "features", featureDir, "tasks", task);
+  const promptPath = path10.join(promptDir, "worker-prompt.md");
+  if (!fs12.existsSync(promptDir)) {
+    fs12.mkdirSync(promptDir, { recursive: true });
   }
-  fs11.writeFileSync(promptPath, prompt, "utf-8");
+  fs12.writeFileSync(promptPath, prompt, "utf-8");
   return promptPath;
 }
 
@@ -23465,9 +23668,48 @@ function normalizeVariant(variant) {
   const trimmed2 = variant.trim();
   return trimmed2.length > 0 ? trimmed2 : undefined;
 }
-function createVariantHook(configService) {
+var BUILT_IN_AGENTS = {
+  "hive-master": { sessionKind: "primary", baseAgent: "hive-master" },
+  "architect-planner": { sessionKind: "primary", baseAgent: "architect-planner" },
+  "swarm-orchestrator": { sessionKind: "primary", baseAgent: "swarm-orchestrator" },
+  "forager-worker": { sessionKind: "task-worker", baseAgent: "forager-worker" },
+  "scout-researcher": { sessionKind: "subagent", baseAgent: "scout-researcher" },
+  "hygienic-reviewer": { sessionKind: "subagent", baseAgent: "hygienic-reviewer" }
+};
+var BASE_AGENT_KIND = {
+  "forager-worker": "task-worker",
+  "hygienic-reviewer": "subagent"
+};
+function classifySession(agent, customAgents = {}) {
+  const builtIn = BUILT_IN_AGENTS[agent];
+  if (builtIn) {
+    return { sessionKind: builtIn.sessionKind, baseAgent: builtIn.baseAgent };
+  }
+  const custom2 = customAgents[agent];
+  if (custom2) {
+    const kind = BASE_AGENT_KIND[custom2.baseAgent];
+    if (kind) {
+      return { sessionKind: kind, baseAgent: custom2.baseAgent };
+    }
+  }
+  return { sessionKind: "unknown", baseAgent: undefined };
+}
+function createVariantHook(configService, sessionService, customAgents, taskWorkerRecovery) {
   return async (input, output) => {
     const { agent } = input;
+    if (agent && sessionService) {
+      const { sessionKind, baseAgent } = classifySession(agent, customAgents);
+      const patch = { agent, sessionKind };
+      if (baseAgent) {
+        patch.baseAgent = baseAgent;
+      }
+      if (sessionKind === "task-worker" && taskWorkerRecovery) {
+        patch.featureName = taskWorkerRecovery.featureName;
+        patch.taskFolder = taskWorkerRecovery.taskFolder;
+        patch.workerPromptPath = taskWorkerRecovery.workerPromptPath;
+      }
+      sessionService.trackGlobal(input.sessionID, patch);
+    }
     if (!agent)
       return;
     if (!configService.hasConfiguredAgent(agent))
@@ -23501,10 +23743,69 @@ var HIVE_SYSTEM_PROMPT = `
 Use hive_merge to integrate changes into the current branch.
 `;
 
-// src/utils/compaction-prompt.ts
-var COMPACTION_RESUME_PROMPT = "You were compacted mid-task. " + "Resume by reading your worker-prompt.md (in the task worktree root) to recall your assignment. " + "Do not call status tools or re-read the full codebase. " + "Locate your last commit message or notes, then continue from where you left off.";
-function buildCompactionPrompt() {
-  return COMPACTION_RESUME_PROMPT;
+// src/utils/compaction-anchor.ts
+var AGENT_ROLE_MAP = {
+  "hive-master": "Hive",
+  "architect-planner": "Architect",
+  "swarm-orchestrator": "Swarm",
+  "forager-worker": "Forager",
+  "scout-researcher": "Scout",
+  "hygienic-reviewer": "Hygienic"
+};
+var BASE_AGENT_ROLE_MAP = {
+  "forager-worker": "Forager",
+  "hygienic-reviewer": "Hygienic",
+  "scout-researcher": "Scout"
+};
+function resolveRole(ctx) {
+  if (ctx.agent && AGENT_ROLE_MAP[ctx.agent]) {
+    return AGENT_ROLE_MAP[ctx.agent];
+  }
+  if (ctx.baseAgent && BASE_AGENT_ROLE_MAP[ctx.baseAgent]) {
+    return BASE_AGENT_ROLE_MAP[ctx.baseAgent];
+  }
+  return;
+}
+function resolveWorkerPromptPath(ctx) {
+  if (ctx.workerPromptPath) {
+    return ctx.workerPromptPath;
+  }
+  if (ctx.featureName && ctx.taskFolder) {
+    return `.hive/features/${ctx.featureName}/tasks/${ctx.taskFolder}/worker-prompt.md`;
+  }
+  return;
+}
+function buildCompactionReanchor(ctx) {
+  const role = resolveRole(ctx);
+  const kind = ctx.sessionKind ?? "unknown";
+  const workerPromptPath = resolveWorkerPromptPath(ctx);
+  const lines = [];
+  const context = [];
+  lines.push("Compaction recovery — you were compacted mid-session.");
+  if (role) {
+    lines.push(`Role: ${role}`);
+  }
+  lines.push("Do not switch roles.");
+  lines.push("Do not call status tools to rediscover state.");
+  lines.push("Do not re-read the full codebase.");
+  if (kind === "task-worker") {
+    lines.push("Do not delegate.");
+    if (workerPromptPath) {
+      lines.push("Re-read worker-prompt.md now to recall your assignment.");
+      context.push(workerPromptPath);
+    } else {
+      lines.push("Re-read worker-prompt.md from the Hive task metadata to recall your assignment.");
+    }
+  }
+  if ((kind === "primary" || kind === "subagent") && ctx.directivePrompt) {
+    lines.push("Original directive survives via post-compaction replay.");
+  }
+  lines.push("Next action: resume from where you left off.");
+  return {
+    prompt: lines.join(`
+`),
+    context
+  };
 }
 
 // src/index.ts
@@ -23619,13 +23920,14 @@ No Hive skills available.` : base + formatSkillsXml(filteredSkills);
   });
 }
 var plugin = async (ctx) => {
-  const { directory, client } = ctx;
+  const { directory, client, worktree } = ctx;
   const featureService = new FeatureService(directory);
   const planService = new PlanService(directory);
   const taskService = new TaskService(directory);
   const contextService = new ContextService(directory);
   const agentsMdService = new AgentsMdService(directory, contextService);
   const configService = new ConfigService;
+  const sessionService = new SessionService(directory);
   const disabledMcps = configService.getDisabledMcps();
   const disabledSkills = configService.getDisabledSkills();
   const builtinMcps = createBuiltinMcps(disabledMcps);
@@ -23633,8 +23935,15 @@ var plugin = async (ctx) => {
   const effectiveAutoLoadSkills = configService.getAgentConfig("hive-master").autoLoadSkills ?? [];
   const worktreeService = new WorktreeService({
     baseDir: directory,
-    hiveDir: path10.join(directory, ".hive")
+    hiveDir: path11.join(directory, ".hive")
   });
+  const customAgentConfigsForClassification = getCustomAgentConfigsCompat(configService);
+  const runtimeContext = detectContext(worktree || directory);
+  const taskWorkerRecovery = runtimeContext.isWorktree && runtimeContext.feature && runtimeContext.task ? {
+    featureName: runtimeContext.feature,
+    taskFolder: runtimeContext.task,
+    workerPromptPath: path11.posix.join(".hive", "features", resolveFeatureDirectoryName(directory, runtimeContext.feature), "tasks", runtimeContext.task, "worker-prompt.md")
+  } : undefined;
   const isOmoSlimEnabled = () => {
     return configService.isOmoSlimEnabled();
   };
@@ -23655,12 +23964,50 @@ var plugin = async (ctx) => {
       }
     }
   };
+  const bindFeatureSession = (feature, toolContext, patch) => {
+    const ctx2 = toolContext;
+    if (!ctx2?.sessionID)
+      return;
+    sessionService.bindFeature(ctx2.sessionID, feature, patch);
+  };
+  const extractTextParts = (parts) => {
+    if (!Array.isArray(parts))
+      return [];
+    return parts.filter((part) => {
+      return !!part && typeof part === "object" && part.type === "text" && typeof part.text === "string";
+    }).map((part) => part.text.trim()).filter(Boolean);
+  };
+  const shouldCaptureDirective = (info, parts) => {
+    if (info.role !== "user")
+      return false;
+    const textParts = parts.filter((part) => {
+      return !!part && typeof part === "object" && part.type === "text";
+    });
+    if (textParts.length === 0)
+      return false;
+    return !textParts.every((part) => part.synthetic === true);
+  };
+  const buildDirectiveReplayText = (session) => {
+    if (!session.directivePrompt)
+      return null;
+    const role = session.agent === "scout-researcher" || session.baseAgent === "scout-researcher" ? "Scout" : session.agent === "hygienic-reviewer" || session.baseAgent === "hygienic-reviewer" ? "Hygienic" : session.agent === "architect-planner" || session.baseAgent === "architect-planner" ? "Architect" : session.agent === "swarm-orchestrator" || session.baseAgent === "swarm-orchestrator" ? "Swarm" : session.agent === "hive-master" || session.baseAgent === "hive-master" ? "Hive" : "current role";
+    return [
+      `Post-compaction recovery: You are still ${role}.`,
+      "Resume the original assignment below. Do not replace it with a new goal.",
+      "",
+      session.directivePrompt
+    ].join(`
+`);
+  };
+  const shouldUseDirectiveReplay = (session) => {
+    return session?.sessionKind === "primary" || session?.sessionKind === "subagent";
+  };
   const checkBlocked = (feature) => {
-    const fs13 = __require("fs");
+    const fs14 = __require("fs");
     const featureDir = resolveFeatureDirectoryName(directory, feature);
-    const blockedPath = path10.join(directory, ".hive", "features", featureDir, "BLOCKED");
-    if (fs13.existsSync(blockedPath)) {
-      const reason = fs13.readFileSync(blockedPath, "utf-8").trim();
+    const blockedPath = path11.join(directory, ".hive", "features", featureDir, "BLOCKED");
+    if (fs14.existsSync(blockedPath)) {
+      const reason = fs14.readFileSync(blockedPath, "utf-8").trim();
       return `⛔ BLOCKED by Beekeeper
 
 ${reason || "(No reason provided)"}
@@ -23713,13 +24060,13 @@ To unblock: Remove .hive/features/${featureDir}/BLOCKED`;
     feature,
     task,
     taskInfo,
-    worktree,
+    worktree: worktree2,
     continueFrom,
     decision
   }) => {
     taskService.update(feature, task, {
       status: "in_progress",
-      baseCommit: worktree.commit
+      baseCommit: worktree2.commit
     });
     const planResult = planService.read(feature);
     const allTasks = taskService.list(feature);
@@ -23770,8 +24117,8 @@ To unblock: Remove .hive/features/${featureDir}/BLOCKED`;
       feature,
       task,
       taskOrder,
-      worktreePath: worktree.path,
-      branch: worktree.branch,
+      worktreePath: worktree2.path,
+      branch: worktree2.branch,
       plan: planResult?.content || "No plan available",
       contextFiles,
       spec: specContent,
@@ -23813,9 +24160,9 @@ To unblock: Remove .hive/features/${featureDir}/BLOCKED`;
       spec: specContent,
       workerPrompt
     });
-    const hiveDir = path10.join(directory, ".hive");
+    const hiveDir = path11.join(directory, ".hive");
     const workerPromptPath = writeWorkerPromptFile(feature, task, workerPrompt, hiveDir);
-    const relativePromptPath = normalizePath(path10.relative(directory, workerPromptPath));
+    const relativePromptPath = normalizePath(path11.relative(directory, workerPromptPath));
     const PREVIEW_MAX_LENGTH = 200;
     const workerPromptPreview = workerPrompt.length > PREVIEW_MAX_LENGTH ? workerPrompt.slice(0, PREVIEW_MAX_LENGTH) + "..." : workerPrompt;
     const taskToolPrompt = `Follow instructions in @${relativePromptPath}`;
@@ -23844,8 +24191,8 @@ Use the \`@path\` attachment syntax in the prompt to reference the file. Do not
     const responseBase = {
       success: true,
       terminal: false,
-      worktreePath: worktree.path,
-      branch: worktree.branch,
+      worktreePath: worktree2.path,
+      branch: worktree2.branch,
       mode: "delegate",
       agent,
       defaultAgent,
@@ -23981,8 +24328,8 @@ Use the \`@path\` attachment syntax in the prompt to reference the file. Do not
         ]
       });
     }
-    const worktree = await worktreeService.create(feature, task);
-    return buildWorktreeLaunchResponse({ feature, task, taskInfo, worktree });
+    const worktree2 = await worktreeService.create(feature, task);
+    return buildWorktreeLaunchResponse({ feature, task, taskInfo, worktree: worktree2 });
   };
   const executeBlockedResume = async ({
     task,
@@ -24073,8 +24420,8 @@ Use the \`@path\` attachment syntax in the prompt to reference the file. Do not
         ]
       });
     }
-    const worktree = await worktreeService.get(feature, task);
-    if (!worktree) {
+    const worktree2 = await worktreeService.get(feature, task);
+    if (!worktree2) {
       return respond({
         success: false,
         terminal: true,
@@ -24090,12 +24437,23 @@ Use the \`@path\` attachment syntax in the prompt to reference the file. Do not
       feature,
       task,
       taskInfo,
-      worktree,
+      worktree: worktree2,
       continueFrom,
       decision
     });
   };
   return {
+    event: async (input) => {
+      if (input.event.type !== "session.compacted") {
+        return;
+      }
+      const sessionID = input.event.properties.sessionID;
+      const existing = sessionService.getGlobal(sessionID);
+      if (!existing?.directivePrompt || !shouldUseDirectiveReplay(existing)) {
+        return;
+      }
+      sessionService.trackGlobal(sessionID, { replayDirectivePending: true });
+    },
     "experimental.chat.system.transform": async (input, output) => {
       if (!shouldExecuteHook("experimental.chat.system.transform", configService, turnCounters)) {
         return;
@@ -24129,9 +24487,81 @@ Use the \`@path\` attachment syntax in the prompt to reference the file. Do not
       }
     },
     "experimental.session.compacting": async (_input, output) => {
-      output.context.push(buildCompactionPrompt());
+      const session = sessionService.getGlobal(_input.sessionID);
+      if (session) {
+        const ctx2 = {
+          agent: session.agent,
+          baseAgent: session.baseAgent,
+          sessionKind: session.sessionKind,
+          featureName: session.featureName,
+          taskFolder: session.taskFolder,
+          workerPromptPath: session.workerPromptPath,
+          directivePrompt: session.directivePrompt
+        };
+        const reanchor = buildCompactionReanchor(ctx2);
+        output.prompt = reanchor.prompt;
+        output.context.push(...reanchor.context);
+      } else {
+        const reanchor = buildCompactionReanchor({});
+        output.prompt = reanchor.prompt;
+        output.context.push(...reanchor.context);
+      }
+    },
+    "chat.message": createVariantHook(configService, sessionService, customAgentConfigsForClassification, taskWorkerRecovery),
+    "experimental.chat.messages.transform": async (_input, output) => {
+      if (!Array.isArray(output.messages) || output.messages.length === 0) {
+        return;
+      }
+      const firstMessage = output.messages[0];
+      const sessionID = firstMessage?.info?.sessionID;
+      if (!sessionID) {
+        return;
+      }
+      const session = sessionService.getGlobal(sessionID);
+      const captureCandidates = output.messages.filter(({ info, parts }) => info.sessionID === sessionID && shouldCaptureDirective(info, parts));
+      const latestDirective = captureCandidates.at(-1);
+      if (latestDirective) {
+        const directiveText = extractTextParts(latestDirective.parts).join(`
+
+`);
+        const existingDirective = session?.directivePrompt;
+        if (directiveText && directiveText !== existingDirective && shouldUseDirectiveReplay(session ?? { sessionKind: "subagent" })) {
+          sessionService.trackGlobal(sessionID, { directivePrompt: directiveText });
+        }
+      }
+      const refreshed = sessionService.getGlobal(sessionID);
+      if (!refreshed?.replayDirectivePending || !shouldUseDirectiveReplay(refreshed)) {
+        if (refreshed?.replayDirectivePending && !shouldUseDirectiveReplay(refreshed)) {
+          sessionService.trackGlobal(sessionID, { replayDirectivePending: false });
+        }
+        return;
+      }
+      const replayText = buildDirectiveReplayText(refreshed);
+      if (!replayText) {
+        sessionService.trackGlobal(sessionID, { replayDirectivePending: false });
+        return;
+      }
+      const now = Date.now();
+      output.messages.push({
+        info: {
+          id: `msg_replay_${sessionID}`,
+          sessionID,
+          role: "user",
+          time: { created: now }
+        },
+        parts: [
+          {
+            id: `prt_replay_${sessionID}`,
+            sessionID,
+            messageID: `msg_replay_${sessionID}`,
+            type: "text",
+            text: replayText,
+            synthetic: true
+          }
+        ]
+      });
+      sessionService.trackGlobal(sessionID, { replayDirectivePending: false });
     },
-    "chat.message": createVariantHook(configService),
     "tool.execute.before": async (input, output) => {
       if (!shouldExecuteHook("tool.execute.before", configService, turnCounters, { safetyCritical: true })) {
         return;
@@ -24153,7 +24583,7 @@ Use the \`@path\` attachment syntax in the prompt to reference the file. Do not
       const workdir = output.args?.workdir;
       if (!workdir)
         return;
-      const hiveWorktreeBase = path10.join(directory, ".hive", ".worktrees");
+      const hiveWorktreeBase = path11.join(directory, ".hive", ".worktrees");
       if (!workdir.startsWith(hiveWorktreeBase))
         return;
       const wrapped = DockerSandboxService.wrapCommand(workdir, command, sandboxConfig);
@@ -24267,6 +24697,7 @@ Expand your Discovery section and try again.`;
           if (!feature)
             return "Error: No feature specified. Create a feature or provide feature param.";
           captureSession(feature, toolContext);
+          bindFeatureSession(feature, toolContext);
           const result = planService.read(feature);
           if (!result)
             return "Error: No plan.md found";
@@ -24390,7 +24821,7 @@ Reminder: start work with hive_worktree_start to use its worktree, and ensure an
           }).optional().describe("Blocker info when status is blocked"),
           feature: tool.schema.string().optional().describe("Feature name (defaults to detection or single feature)")
         },
-        async execute({ task, summary, message, status = "completed", blocker, feature: explicitFeature }) {
+        async execute({ task, summary, message, status = "completed", blocker, feature: explicitFeature }, toolContext) {
           const respond2 = (payload) => JSON.stringify(payload, null, 2);
           const feature = resolveFeature(explicitFeature);
           if (!feature) {
@@ -24432,6 +24863,9 @@ Reminder: start work with hive_worktree_start to use its worktree, and ensure an
               nextAction: "Only in_progress or blocked tasks can be committed. Start/resume the task first."
             });
           }
+          const featureDir = resolveFeatureDirectoryName(directory, feature);
+          const workerPromptPath = path11.posix.join(".hive", "features", featureDir, "tasks", task, "worker-prompt.md");
+          bindFeatureSession(feature, toolContext, { taskFolder: task, workerPromptPath });
           let verificationNote;
           if (status === "completed") {
             const verificationKeywords = ["test", "build", "lint", "vitest", "jest", "npm run", "pnpm", "cargo", "pytest", "verified", "passes", "succeeds", "ast-grep", "scan"];
@@ -24447,7 +24881,7 @@ Reminder: start work with hive_worktree_start to use its worktree, and ensure an
               summary,
               blocker
             });
-            const worktree2 = await worktreeService.get(feature, task);
+            const worktree3 = await worktreeService.get(feature, task);
             return respond2({
               ok: true,
               terminal: true,
@@ -24458,8 +24892,8 @@ Reminder: start work with hive_worktree_start to use its worktree, and ensure an
               taskState: "blocked",
               summary,
               blocker,
-              worktreePath: worktree2?.path,
-              branch: worktree2?.branch,
+              worktreePath: worktree3?.path,
+              branch: worktree3?.branch,
               message: 'Task blocked. Hive Master will ask user and resume with hive_worktree_create(continueFrom: "blocked", decision: answer)',
               nextAction: 'Wait for orchestrator to collect user decision and resume with continueFrom: "blocked".'
             });
@@ -24518,7 +24952,7 @@ Reminder: start work with hive_worktree_start to use its worktree, and ensure an
 `));
           const finalStatus = status === "completed" ? "done" : status;
           taskService.update(feature, task, { status: finalStatus, summary });
-          const worktree = await worktreeService.get(feature, task);
+          const worktree2 = await worktreeService.get(feature, task);
           return respond2({
             ok: true,
             terminal: true,
@@ -24533,8 +24967,8 @@ Reminder: start work with hive_worktree_start to use its worktree, and ensure an
               sha: commitResult.sha,
               message: commitResult.message
             },
-            worktreePath: worktree?.path,
-            branch: worktree?.branch,
+            worktreePath: worktree2?.path,
+            branch: worktree2?.branch,
             reportPath,
             message: `Task "${task}" ${status}.`,
             nextAction: "Use hive_merge to integrate changes. Worktree is preserved for review."
@@ -24596,10 +25030,11 @@ Files changed: ${result.filesChanged?.length || 0}`;
           content: tool.schema.string().describe("Markdown content to write"),
           feature: tool.schema.string().optional().describe("Feature name (defaults to active)")
         },
-        async execute({ name, content, feature: explicitFeature }) {
+        async execute({ name, content, feature: explicitFeature }, toolContext) {
           const feature = resolveFeature(explicitFeature);
           if (!feature)
             return "Error: No feature specified. Create a feature or provide feature param.";
+          bindFeatureSession(feature, toolContext);
           const filePath = contextService.write(feature, name, content);
           return `Context file written: ${filePath}`;
         }
@@ -24649,36 +25084,36 @@ Files changed: ${result.filesChanged?.length || 0}`;
           const contextFiles = contextService.list(feature);
           const overview = contextFiles.find((file2) => file2.name === "overview") ?? null;
           const readThreads = (filePath) => {
-            if (!fs12.existsSync(filePath)) {
+            if (!fs13.existsSync(filePath)) {
               return null;
             }
             try {
-              const data = JSON.parse(fs12.readFileSync(filePath, "utf-8"));
+              const data = JSON.parse(fs13.readFileSync(filePath, "utf-8"));
               return data.threads ?? [];
             } catch {
               return [];
             }
           };
-          const featurePath = path10.join(directory, ".hive", "features", resolveFeatureDirectoryName(directory, feature));
-          const reviewDir = path10.join(featurePath, "comments");
-          const planThreads = readThreads(path10.join(reviewDir, "plan.json")) ?? readThreads(path10.join(featurePath, "comments.json"));
-          const overviewThreads = readThreads(path10.join(reviewDir, "overview.json"));
+          const featurePath = path11.join(directory, ".hive", "features", resolveFeatureDirectoryName(directory, feature));
+          const reviewDir = path11.join(featurePath, "comments");
+          const planThreads = readThreads(path11.join(reviewDir, "plan.json")) ?? readThreads(path11.join(featurePath, "comments.json"));
+          const overviewThreads = readThreads(path11.join(reviewDir, "overview.json"));
           const reviewCounts = {
             plan: planThreads?.length ?? 0,
             overview: overviewThreads?.length ?? 0
           };
           const tasksSummary = await Promise.all(tasks.map(async (t) => {
             const rawStatus = taskService.getRawStatus(feature, t.folder);
-            const worktree = await worktreeService.get(feature, t.folder);
-            const hasChanges = worktree ? await worktreeService.hasUncommittedChanges(worktree.feature, worktree.step) : null;
+            const worktree2 = await worktreeService.get(feature, t.folder);
+            const hasChanges = worktree2 ? await worktreeService.hasUncommittedChanges(worktree2.feature, worktree2.step) : null;
             return {
               folder: t.folder,
               name: t.name,
               status: t.status,
               origin: t.origin || "plan",
               dependsOn: rawStatus?.dependsOn ?? null,
-              worktree: worktree ? {
-                branch: worktree.branch,
+              worktree: worktree2 ? {
+                branch: worktree2.branch,
                 hasChanges
               } : null
             };

package/dist/opencode-hive/src/hooks/variant-hook.d.ts

@@ -1,6 +1,18 @@
-import type { ConfigService } from 'hive-core';
+import type { ConfigService, SessionService, SessionKind } from 'hive-core';
 export declare function normalizeVariant(variant: string | undefined): string | undefined;
-export declare function createVariantHook(configService: ConfigService): (input: {
+export declare function classifySession(agent: string, customAgents?: Record<string, {
+    baseAgent: string;
+}>): {
+    sessionKind: SessionKind;
+    baseAgent?: string;
+};
+export declare function createVariantHook(configService: ConfigService, sessionService?: SessionService, customAgents?: Record<string, {
+    baseAgent: string;
+}>, taskWorkerRecovery?: {
+    featureName: string;
+    taskFolder: string;
+    workerPromptPath: string;
+}): (input: {
     sessionID: string;
     agent?: string;
     model?: {

package/dist/opencode-hive/src/utils/compaction-anchor.d.ts

@@ -0,0 +1,14 @@
+export interface CompactionSessionContext {
+    agent?: string;
+    baseAgent?: string;
+    sessionKind?: 'primary' | 'subagent' | 'task-worker' | 'unknown';
+    featureName?: string;
+    taskFolder?: string;
+    workerPromptPath?: string;
+    directivePrompt?: string;
+}
+export interface CompactionReanchor {
+    prompt: string;
+    context: string[];
+}
+export declare function buildCompactionReanchor(ctx: CompactionSessionContext): CompactionReanchor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-hive",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "type": "module",
   "description": "OpenCode plugin for Agent Hive - from vibe coding to hive coding",
   "license": "MIT WITH Commons-Clause",
@@ -39,17 +39,17 @@
     "simple-git": "^3.27.0"
   },
   "optionalDependencies": {
-    "grep-mcp": "^1.1.0",
     "@notprolands/ast-grep-mcp": "^1.1.1",
     "@upstash/context7-mcp": "^2.1.0",
-    "exa-mcp-server": "^3.1.5"
+    "exa-mcp-server": "^3.1.5",
+    "grep-mcp": "^1.1.0"
   },
   "devDependencies": {
-    "hive-core": "workspace:*",
     "@opencode-ai/plugin": "^1.0.143",
     "@opencode-ai/sdk": "^0.13.0",
     "@types/bun": "^1.2.0",
     "@types/node": "^20.0.0",
+    "hive-core": "workspace:*",
     "typescript": "^5.0.0"
   },
   "files": [