@jmylchreest/aide-plugin 0.0.25 → 0.0.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jmylchreest/aide-plugin",
-  "version": "0.0.25",
+  "version": "0.0.26",
   "description": "aide plugin for OpenCode — multi-agent orchestration, memory, skills, and persistence",
   "type": "module",
   "main": "./src/opencode/index.ts",

package/src/core/index.ts

@@ -13,6 +13,7 @@ export * from "./tool-tracking.js";
 export * from "./persistence-logic.js";
 export * from "./session-summary-logic.js";
 export * from "./pre-compact-logic.js";
+export * from "./partial-memory.js";
 export * from "./cleanup.js";
 export * from "./mcp-sync.js";
 export * from "./tool-enforcement.js";

package/src/core/partial-memory.ts

@@ -0,0 +1,354 @@
+/**
+ * Partial memory logic — platform-agnostic.
+ *
+ * Writes granular "partial" memories on significant tool events.
+ * These are tagged with "partial" so they:
+ * - Are excluded from normal recall (via ExcludeTags)
+ * - Can be gathered and rolled up into a final session summary
+ * - Get cleaned up (tagged "forget") after the final summary is written
+ *
+ * What counts as "significant":
+ * - Write/Edit/MultiEdit to a file (code change)
+ * - Bash commands that succeed (shell operations)
+ * - Task tool completions (subagent work)
+ * - NOT: Read, Grep, Glob (pure reads — no side effects)
+ */
+
+import { execFileSync } from "child_process";
+import { debug } from "../lib/logger.js";
+
+const SOURCE = "partial-memory";
+
+/** Tools that represent significant (state-changing) actions */
+const SIGNIFICANT_TOOLS = new Set([
+  "Write",
+  "Edit",
+  "MultiEdit",
+  "Bash",
+  "Task",
+]);
+
+/** Information about a completed tool use */
+export interface ToolCompletionInfo {
+  toolName: string;
+  sessionId: string;
+  /** File path affected (Write/Edit) */
+  filePath?: string;
+  /** Bash command executed */
+  command?: string;
+  /** Task description */
+  description?: string;
+  /** Whether the tool succeeded */
+  success?: boolean;
+}
+
+/**
+ * Check whether a tool completion is "significant" enough to write a partial.
+ */
+export function isSignificantToolUse(info: ToolCompletionInfo): boolean {
+  if (!SIGNIFICANT_TOOLS.has(info.toolName)) return false;
+
+  // For Bash, only track if we have a command (skip empty/failed)
+  if (info.toolName === "Bash") {
+    if (!info.command) return false;
+    // Skip trivial read-only commands
+    const cmd = info.command.trim().toLowerCase();
+    if (
+      cmd.startsWith("cat ") ||
+      cmd.startsWith("ls ") ||
+      cmd.startsWith("echo ") ||
+      cmd.startsWith("pwd") ||
+      cmd.startsWith("which ") ||
+      cmd.startsWith("type ")
+    ) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Build a concise partial memory content string from tool completion info.
+ */
+export function buildPartialContent(info: ToolCompletionInfo): string {
+  switch (info.toolName) {
+    case "Write":
+      return info.filePath
+        ? `Created file: ${info.filePath}`
+        : "Created a file";
+    case "Edit":
+    case "MultiEdit":
+      return info.filePath ? `Edited file: ${info.filePath}` : "Edited a file";
+    case "Bash": {
+      const cmd =
+        info.command && info.command.length > 100
+          ? info.command.slice(0, 97) + "..."
+          : info.command;
+      return `Ran command: ${cmd}`;
+    }
+    case "Task":
+      return info.description
+        ? `Completed task: ${info.description}`
+        : "Completed a subtask";
+    default:
+      return `Used tool: ${info.toolName}`;
+  }
+}
+
+/**
+ * Build the tags for a partial memory.
+ */
+export function buildPartialTags(
+  sessionId: string,
+  info: ToolCompletionInfo,
+): string[] {
+  const tags = [
+    "partial",
+    `session:${sessionId.slice(0, 8)}`,
+    `tool:${info.toolName.toLowerCase()}`,
+  ];
+  if (info.filePath) {
+    // Add a tag for the file extension to allow grouping
+    const ext = info.filePath.split(".").pop();
+    if (ext) tags.push(`ext:${ext}`);
+  }
+  return tags;
+}
+
+/**
+ * Store a partial memory for a significant tool event.
+ *
+ * Returns true if stored successfully.
+ */
+export function storePartialMemory(
+  binary: string,
+  cwd: string,
+  info: ToolCompletionInfo,
+): boolean {
+  if (!isSignificantToolUse(info)) return false;
+
+  try {
+    const content = buildPartialContent(info);
+    const tags = buildPartialTags(info.sessionId, info);
+
+    execFileSync(
+      binary,
+      [
+        "memory",
+        "add",
+        "--category=session",
+        `--tags=${tags.join(",")}`,
+        content,
+      ],
+      { cwd, stdio: "pipe", timeout: 3000 },
+    );
+
+    debug(SOURCE, `Stored partial: ${content} [${tags.join(", ")}]`);
+    return true;
+  } catch (err) {
+    debug(SOURCE, `Failed to store partial (non-fatal): ${err}`);
+    return false;
+  }
+}
+
+/**
+ * Gather all partial memories for a session.
+ *
+ * Uses `aide memory list` with tag filtering to find all partials.
+ * Returns the raw output or null if none found.
+ */
+export function gatherPartials(
+  binary: string,
+  cwd: string,
+  sessionId: string,
+): string[] {
+  try {
+    const sessionTag = `session:${sessionId.slice(0, 8)}`;
+
+    const output = execFileSync(
+      binary,
+      [
+        "memory",
+        "list",
+        "--tags=partial",
+        "--all", // Include even if tagged forget (shouldn't be, but defensive)
+        "--format=json",
+        "--limit=500",
+      ],
+      {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 5000,
+      },
+    ).trim();
+
+    if (!output || output === "[]") return [];
+
+    interface PartialMemory {
+      id: string;
+      tags: string[];
+      content: string;
+    }
+
+    const memories: PartialMemory[] = JSON.parse(output);
+    // Filter to this session's partials
+    return memories
+      .filter((m) => m.tags?.includes(sessionTag))
+      .map((m) => m.content);
+  } catch (err) {
+    debug(SOURCE, `Failed to gather partials: ${err}`);
+    return [];
+  }
+}
+
+/**
+ * Gather partial memory IDs for a session (for cleanup).
+ */
+export function gatherPartialIds(
+  binary: string,
+  cwd: string,
+  sessionId: string,
+): string[] {
+  try {
+    const sessionTag = `session:${sessionId.slice(0, 8)}`;
+
+    const output = execFileSync(
+      binary,
+      [
+        "memory",
+        "list",
+        "--tags=partial",
+        "--all",
+        "--format=json",
+        "--limit=500",
+      ],
+      {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 5000,
+      },
+    ).trim();
+
+    if (!output || output === "[]") return [];
+
+    interface PartialMemory {
+      id: string;
+      tags: string[];
+    }
+
+    const memories: PartialMemory[] = JSON.parse(output);
+    return memories
+      .filter((m) => m.tags?.includes(sessionTag))
+      .map((m) => m.id);
+  } catch (err) {
+    debug(SOURCE, `Failed to gather partial IDs: ${err}`);
+    return [];
+  }
+}
+
+/**
+ * Clean up partials for a session by tagging them as "forget".
+ *
+ * This soft-deletes them so they won't appear in future queries
+ * but remain recoverable if needed.
+ */
+export function cleanupPartials(
+  binary: string,
+  cwd: string,
+  sessionId: string,
+): number {
+  const ids = gatherPartialIds(binary, cwd, sessionId);
+  let cleaned = 0;
+
+  for (const id of ids) {
+    try {
+      execFileSync(binary, ["memory", "tag", id, "--add=forget"], {
+        cwd,
+        stdio: "pipe",
+        timeout: 3000,
+      });
+      cleaned++;
+    } catch (err) {
+      debug(SOURCE, `Failed to cleanup partial ${id}: ${err}`);
+    }
+  }
+
+  if (cleaned > 0) {
+    debug(
+      SOURCE,
+      `Cleaned up ${cleaned} partials for session ${sessionId.slice(0, 8)}`,
+    );
+  }
+  return cleaned;
+}
+
+/**
+ * Build a final session summary that incorporates partials.
+ *
+ * If partials are available, they're included alongside git data
+ * to produce a richer summary than either source alone.
+ */
+export function buildSummaryFromPartials(
+  partials: string[],
+  gitCommits: string[],
+  gitFiles: string[],
+): string | null {
+  const summaryParts: string[] = [];
+
+  // Deduplicate and categorise partials
+  const fileChanges = new Set<string>();
+  const commands: string[] = [];
+  const tasks: string[] = [];
+  const other: string[] = [];
+
+  for (const p of partials) {
+    if (p.startsWith("Created file: ") || p.startsWith("Edited file: ")) {
+      fileChanges.add(p.replace(/^(Created|Edited) file: /, ""));
+    } else if (p.startsWith("Ran command: ")) {
+      commands.push(p.replace("Ran command: ", ""));
+    } else if (p.startsWith("Completed task: ")) {
+      tasks.push(p.replace("Completed task: ", ""));
+    } else {
+      other.push(p);
+    }
+  }
+
+  if (tasks.length > 0) {
+    summaryParts.push(
+      `## Tasks\n${tasks
+        .slice(0, 5)
+        .map((t) => `- ${t}`)
+        .join("\n")}`,
+    );
+  }
+
+  if (gitCommits.length > 0) {
+    summaryParts.push(
+      `## Commits\n${gitCommits.map((c) => `- ${c}`).join("\n")}`,
+    );
+  }
+
+  // Merge file changes from partials and git
+  const allFiles = new Set([...fileChanges, ...gitFiles]);
+  if (allFiles.size > 0) {
+    const files = Array.from(allFiles).slice(0, 15);
+    summaryParts.push(
+      `## Files Modified\n${files.map((f) => `- ${f}`).join("\n")}`,
+    );
+  }
+
+  if (commands.length > 0) {
+    summaryParts.push(
+      `## Commands\n${commands
+        .slice(0, 10)
+        .map((c) => `- ${c}`)
+        .join("\n")}`,
+    );
+  }
+
+  const summary = summaryParts.join("\n\n");
+  return summary.length >= 50 ? summary : null;
+}

package/src/core/session-init.ts

@@ -241,8 +241,6 @@ export function runSessionInit(
     return result;
   }
 
-  const dbPath = join(cwd, ".aide", "memory", "store.db");
-
   try {
     const args = [
       "session",
@@ -255,7 +253,6 @@ export function runSessionInit(
       cwd,
       encoding: "utf-8",
       timeout: 15000,
-      env: { ...process.env, AIDE_MEMORY_DB: dbPath },
     }).trim();
 
     if (!output) return result;

package/src/core/session-summary-logic.ts

@@ -169,9 +169,7 @@ export function buildSessionSummaryFromState(cwd: string): string | null {
   const summaryParts: string[] = [];
 
   if (commits.length > 0) {
-    summaryParts.push(
-      `## Commits\n${commits.map((c) => `- ${c}`).join("\n")}`,
-    );
+    summaryParts.push(`## Commits\n${commits.map((c) => `- ${c}`).join("\n")}`);
   }
 
   // Check for modified files via git
@@ -216,14 +214,12 @@ export function storeSessionSummary(
   summary: string,
 ): boolean {
   try {
-    const dbPath = join(cwd, ".aide", "memory", "store.db");
-    const env = { ...process.env, AIDE_MEMORY_DB: dbPath };
     const tags = `session-summary,session:${sessionId.slice(0, 8)}`;
 
     execFileSync(
       binary,
       ["memory", "add", "--category=session", `--tags=${tags}`, summary],
-      { env, stdio: "pipe", timeout: 5000 },
+      { cwd, stdio: "pipe", timeout: 5000 },
     );
 
     return true;

package/src/opencode/hooks.ts

@@ -25,6 +25,7 @@
  *   Stop (blocking)            → session.idle re-prompts via session.prompt() for persistence
  */
 
+import { execFileSync } from "child_process";
 import { findAideBinary } from "../core/aide-client.js";
 import {
   ensureDirectories,
@@ -56,10 +57,24 @@ import { saveStateSnapshot } from "../core/pre-compact-logic.js";
 import { cleanupSession } from "../core/cleanup.js";
 import {
   buildSessionSummaryFromState,
+  getSessionCommits,
   storeSessionSummary,
 } from "../core/session-summary-logic.js";
+import {
+  storePartialMemory,
+  gatherPartials,
+  buildSummaryFromPartials,
+  cleanupPartials,
+} from "../core/partial-memory.js";
 import type { MemoryInjection, SessionState } from "../core/types.js";
-import type { Hooks, OpenCodeClient, OpenCodeEvent } from "./types.js";
+import type {
+  Hooks,
+  OpenCodeClient,
+  OpenCodeConfig,
+  OpenCodeEvent,
+  OpenCodeSession,
+  OpenCodePart,
+} from "./types.js";
 import { debug } from "../lib/logger.js";
 
 const SOURCE = "opencode-hooks";
@@ -130,6 +145,8 @@ export async function createHooks(
 
   return {
     event: createEventHandler(state),
+    config: createConfigHandler(state),
+    "command.execute.before": createCommandHandler(state),
     "tool.execute.before": createToolBeforeHandler(state),
     "tool.execute.after": createToolAfterHandler(state),
     "experimental.session.compacting": createCompactionHandler(state),
@@ -139,6 +156,94 @@ export async function createHooks(
   };
 }
 
+// =============================================================================
+// Config handler (register aide commands as OpenCode slash commands)
+// =============================================================================
+
+function createConfigHandler(
+  state: AideState,
+): (input: OpenCodeConfig) => Promise<void> {
+  return async (input) => {
+    try {
+      // Discover all skills and register them as OpenCode commands
+      const skills = discoverSkills(state.cwd, state.pluginRoot ?? undefined);
+
+      if (!input.command) {
+        input.command = {};
+      }
+
+      for (const skill of skills) {
+        const commandName = `aide:${skill.name}`;
+        // Only register if not already defined (user config takes priority)
+        if (!input.command[commandName]) {
+          input.command[commandName] = {
+            template: `Activate the aide "${skill.name}" skill. {{arguments}}`,
+            description: skill.description || `aide ${skill.name} skill`,
+          };
+        }
+      }
+
+      debug(
+        SOURCE,
+        `Registered ${skills.length} aide commands via config hook`,
+      );
+    } catch (err) {
+      debug(SOURCE, `Config hook failed (non-fatal): ${err}`);
+    }
+  };
+}
+
+// =============================================================================
+// Command handler (intercept aide slash command execution)
+// =============================================================================
+
+function createCommandHandler(state: AideState): (
+  input: { command: string; sessionID: string; arguments: string },
+  output: {
+    parts: Array<{ type: string; text: string; [key: string]: unknown }>;
+  },
+) => Promise<void> {
+  return async (input, output) => {
+    // Only handle aide: prefixed commands
+    if (!input.command.startsWith("aide:")) return;
+
+    const skillName = input.command.slice("aide:".length);
+    const args = input.arguments || "";
+
+    try {
+      const skills = discoverSkills(state.cwd, state.pluginRoot ?? undefined);
+      const skill = skills.find((s) => s.name === skillName);
+
+      if (skill) {
+        // Format the skill content for injection
+        const context = formatSkillsContext([skill]);
+
+        // Store for system transform injection
+        state.pendingSkillsContext = context;
+
+        // Also store the arguments as the user prompt for the transform
+        if (args) {
+          state.lastUserPrompt = args;
+        }
+
+        debug(SOURCE, `Command handler activated skill: ${skillName}`);
+
+        await state.client.app.log({
+          body: {
+            service: "aide",
+            level: "info",
+            message: `Activated skill: ${skillName}${args ? ` with args: ${args.slice(0, 50)}` : ""}`,
+          },
+        });
+      } else {
+        debug(SOURCE, `Command handler: unknown skill "${skillName}"`);
+      }
+    } catch (err) {
+      debug(SOURCE, `Command handler failed (non-fatal): ${err}`);
+    }
+  };
+}
+
 // =============================================================================
 // Initialization
 // =============================================================================
@@ -202,11 +307,33 @@ function createEventHandler(
   };
 }
 
+/**
+ * Extract session ID from an event. OpenCode uses different shapes:
+ * - session.created/deleted/updated: { properties: { info: { id: string } } }
+ * - session.idle/compacted:          { properties: { sessionID: string } }
+ * - message.part.updated:            { properties: { part: { sessionID: string } } }
+ */
+function extractSessionId(event: OpenCodeEvent): string {
+  // session.created / session.deleted / session.updated — nested under info
+  const info = event.properties.info as OpenCodeSession | undefined;
+  if (info?.id) return info.id;
+
+  // session.idle, session.compacted, tool hooks — direct sessionID
+  const sessionID = event.properties.sessionID as string | undefined;
+  if (sessionID) return sessionID;
+
+  // message.part.updated — sessionID on the part object
+  const part = event.properties.part as OpenCodePart | undefined;
+  if (part && "sessionID" in part && part.sessionID) return part.sessionID;
+
+  return "unknown";
+}
+
 async function handleSessionCreated(
   state: AideState,
   event: OpenCodeEvent,
 ): Promise<void> {
-  const sessionId = (event.properties.sessionID as string) || "unknown";
+  const sessionId = extractSessionId(event);
 
   if (state.initializedSessions.has(sessionId)) return;
   state.initializedSessions.add(sessionId);
@@ -261,7 +388,7 @@ async function handleSessionIdle(
   state: AideState,
   event: OpenCodeEvent,
 ): Promise<void> {
-  const sessionId = (event.properties.sessionID as string) || "unknown";
+  const sessionId = extractSessionId(event);
 
   // Check persistence: if ralph/autopilot mode is active, re-prompt the session
   if (state.binary) {
@@ -313,10 +440,32 @@ async function handleSessionIdle(
   }
 
   // Capture session summary (best effort, no transcript available)
+  // Uses partials if available for a richer summary.
   if (state.binary) {
-    const summary = buildSessionSummaryFromState(state.cwd);
+    const partials = gatherPartials(state.binary, state.cwd, sessionId);
+    let summary: string | null = null;
+
+    if (partials.length > 0) {
+      const commits = getSessionCommits(state.cwd);
+      summary = buildSummaryFromPartials(partials, commits, []);
+      debug(SOURCE, `Built summary from ${partials.length} partials`);
+    }
+
+    // Fall back to state-only summary if no partials
+    if (!summary) {
+      summary = buildSessionSummaryFromState(state.cwd);
+    }
+
     if (summary) {
       storeSessionSummary(state.binary, state.cwd, sessionId, summary);
+      // Clean up partials now that the final summary is stored
+      const cleaned = cleanupPartials(state.binary, state.cwd, sessionId);
+      if (cleaned > 0) {
+        debug(SOURCE, `Cleaned up ${cleaned} partials after final summary`);
+      }
+    } else if (partials.length > 0) {
+      // Clean up partials even if no summary was generated
+      cleanupPartials(state.binary, state.cwd, sessionId);
     }
   }
 }
@@ -325,7 +474,7 @@ async function handleSessionDeleted(
   state: AideState,
   event: OpenCodeEvent,
 ): Promise<void> {
-  const sessionId = (event.properties.sessionID as string) || "unknown";
+  const sessionId = extractSessionId(event);
 
   if (state.binary) {
     cleanupSession(state.binary, state.cwd, sessionId);
@@ -340,19 +489,17 @@ async function handleMessagePartUpdated(
   state: AideState,
   event: OpenCodeEvent,
 ): Promise<void> {
-  // Skill injection: only process user messages
-  const part = event.properties.part as
-    | { type?: string; text?: string; role?: string }
-    | undefined;
+  // Skill injection: only process user text parts
+  const part = event.properties.part as OpenCodePart | undefined;
   if (!part) return;
 
-  // Only match skills for user text parts
-  const role = (event.properties.role as string) || part.role;
-  if (role !== "user") return;
-  if (part.type !== "text" || !part.text) return;
+  // Only match skills for text parts (user messages)
+  if (part.type !== "text") return;
+  const textContent = (part as { text?: string }).text;
+  if (!textContent) return;
 
   // Dedup: don't re-process the same part
-  const partId = (event.properties.partID as string) || "";
+  const partId = part.id || "";
   if (partId && state.processedMessageParts.has(partId)) return;
   if (partId) state.processedMessageParts.add(partId);
 
@@ -370,7 +517,7 @@ async function handleMessagePartUpdated(
     );
   }
 
-  const prompt = part.text;
+  const prompt = textContent;
 
   // Store latest user prompt so system transform can match skills even if
   // this event fires after the transform (defensive against ordering).
@@ -480,6 +627,23 @@ function createToolAfterHandler(
 
     updateToolStats(state.binary, state.cwd, input.tool, input.sessionID);
 
+    // Write a partial memory for significant tool uses
+    try {
+      const toolArgs = (_output.metadata?.args || {}) as Record<
+        string,
+        unknown
+      >;
+      storePartialMemory(state.binary, state.cwd, {
+        toolName: input.tool,
+        sessionId: input.sessionID,
+        filePath: toolArgs.file_path as string | undefined,
+        command: toolArgs.command as string | undefined,
+        description: toolArgs.description as string | undefined,
+      });
+    } catch (err) {
+      debug(SOURCE, `Partial memory write failed (non-fatal): ${err}`);
+    }
+
     // Comment checker: detect excessive comments in Write/Edit output
     try {
       const toolArgs = (_output.metadata?.args || {}) as Record<
@@ -524,18 +688,40 @@ function createCompactionHandler(
 
       // Persist a session summary as a memory before context is compacted.
       // This ensures the work-so-far is recoverable after compaction.
+      // Uses partials (if available) for a richer summary, falling back to git-only.
       try {
-        const summary = buildSessionSummaryFromState(state.cwd);
+        const partials = gatherPartials(
+          state.binary,
+          state.cwd,
+          input.sessionID,
+        );
+        let summary: string | null = null;
+
+        if (partials.length > 0) {
+          const commits = getSessionCommits(state.cwd);
+          summary = buildSummaryFromPartials(partials, commits, []);
+          debug(
+            SOURCE,
+            `Built pre-compact summary from ${partials.length} partials`,
+          );
+        }
+
+        // Fall back to state-only summary if no partials
+        if (!summary) {
+          summary = buildSessionSummaryFromState(state.cwd);
+        }
+
         if (summary) {
-          storeSessionSummary(
+          // Tag as partial so the session-end summary supersedes it
+          const tags = `partial,session-summary,session:${input.sessionID.slice(0, 8)}`;
+          execFileSync(
             state.binary,
-            state.cwd,
-            input.sessionID,
-            summary,
+            ["memory", "add", "--category=session", `--tags=${tags}`, summary],
+            { cwd: state.cwd, stdio: "pipe", timeout: 5000 },
           );
           debug(
             SOURCE,
-            `Saved pre-compaction session summary for ${input.sessionID.slice(0, 8)}`,
+            `Saved pre-compaction partial session summary for ${input.sessionID.slice(0, 8)}`,
           );
         }
       } catch (err) {

package/src/opencode/types.ts

@@ -31,7 +31,9 @@ export interface PluginInput {
 /** Minimal SDK client interface — only the parts we use */
 export interface OpenCodeClient {
   app: {
-    log(opts: { body: { service: string; level: string; message: string } }): Promise<void>;
+    log(opts: {
+      body: { service: string; level: string; message: string };
+    }): Promise<void>;
   };
   session: {
     create(opts: { body: { title?: string } }): Promise<{ id: string }>;
@@ -54,11 +56,86 @@ export interface OpenCodeClient {
 // Events
 // =============================================================================
 
+/** Session object as returned in session.created/updated/deleted events */
+export interface OpenCodeSession {
+  id: string;
+  projectID: string;
+  directory: string;
+  parentID?: string;
+  title: string;
+  version: string;
+  time: {
+    created: number;
+    updated: number;
+    compacting?: number;
+  };
+}
+
+/** Text part with session context */
+export interface OpenCodeTextPart {
+  id: string;
+  sessionID: string;
+  messageID: string;
+  type: "text";
+  text: string;
+  synthetic?: boolean;
+  ignored?: boolean;
+}
+
+/** Generic part — may be text, tool, step, etc. */
+export type OpenCodePart =
+  | OpenCodeTextPart
+  | {
+      id: string;
+      sessionID: string;
+      messageID: string;
+      type: string;
+      [key: string]: unknown;
+    };
+
 export interface OpenCodeEvent {
   type: string;
   properties: Record<string, unknown>;
 }
 
+/** Typed event shapes matching the OpenCode SDK */
+export interface EventSessionCreated {
+  type: "session.created";
+  properties: { info: OpenCodeSession };
+}
+
+export interface EventSessionDeleted {
+  type: "session.deleted";
+  properties: { info: OpenCodeSession };
+}
+
+export interface EventSessionIdle {
+  type: "session.idle";
+  properties: { sessionID: string };
+}
+
+export interface EventMessagePartUpdated {
+  type: "message.part.updated";
+  properties: { part: OpenCodePart; delta?: string };
+}
+
+// =============================================================================
+// OpenCode Config (command registration)
+// =============================================================================
+
+export interface OpenCodeConfig {
+  command?: {
+    [key: string]: {
+      template: string;
+      description?: string;
+      agent?: string;
+      model?: string;
+      subtask?: boolean;
+    };
+  };
+  [key: string]: unknown;
+}
+
 // =============================================================================
 // Hook signatures
 // =============================================================================
@@ -67,6 +144,17 @@ export interface Hooks {
   /** Generic event listener for all OpenCode events */
   event?: (input: { event: OpenCodeEvent }) => Promise<void>;
 
+  /** Modify OpenCode config (register commands, etc.) */
+  config?: (input: OpenCodeConfig) => Promise<void>;
+
+  /** Intercept command execution (slash commands) */
+  "command.execute.before"?: (
+    input: { command: string; sessionID: string; arguments: string },
+    output: {
+      parts: Array<{ type: string; text: string; [key: string]: unknown }>;
+    },
+  ) => Promise<void>;
+
   /** Modify tool arguments before execution */
   "tool.execute.before"?: (
     input: { tool: string; sessionID: string; callID: string },
@@ -76,12 +164,19 @@ export interface Hooks {
   /** React after tool completes */
   "tool.execute.after"?: (
     input: { tool: string; sessionID: string; callID: string },
-    output: { title: string; output: string; metadata: Record<string, unknown> },
+    output: {
+      title: string;
+      output: string;
+      metadata: Record<string, unknown>;
+    },
   ) => Promise<void>;
 
   /** Modify system prompt */
   "experimental.chat.system.transform"?: (
-    input: { sessionID?: string; model: { providerID: string; modelID: string } },
+    input: {
+      sessionID?: string;
+      model: { providerID: string; modelID: string };
+    },
     output: { system: string[] },
   ) => Promise<void>;