@ericsanchezok/synergy-plugin 1.1.28 → 1.2.1

package/README.md

@@ -0,0 +1,405 @@
+# Synergy Plugin SDK
+
+`@ericsanchezok/synergy-plugin` is the server-side plugin SDK for Synergy.
+
+A plugin extends the runtime with one or more of these capabilities:
+
+- custom tools
+- lifecycle hooks around sessions, agenda runs, notes, engram search, and tool execution
+- provider auth integration
+- config and event observers
+
+This package is for developers who want to add behavior to the Synergy runtime itself. Plugins do **not** run in the Web client. They run on the server/runtime side, inside the active Scope context, and can access:
+
+- `ctx.client` — a Synergy SDK client pointed at the current server
+- `ctx.scope` — the resolved Scope
+- `ctx.directory` / `ctx.worktree` — the current workspace paths
+- `ctx.serverUrl` — the current server URL
+- `ctx.$` — Bun shell access for local runtime-side commands
+
+If you want the smallest possible example, see [`src/example.ts`](./src/example.ts). It is intentionally minimal. The example in this README shows a more realistic shape.
+
+## What a plugin looks like
+
+A plugin module exports one or more async functions of type `Plugin`.
+Each function is initialized once and returns a set of hooks and capabilities.
+In practice, most plugins should export a single default plugin function.
+
+```ts
+import type { Plugin } from "@ericsanchezok/synergy-plugin"
+
+const MyPlugin: Plugin = async (ctx) => {
+  return {
+    // hooks, tools, auth, config observer, event observer
+  }
+}
+
+export default MyPlugin
+```
+
+A plugin function receives this runtime context:
+
+```ts
+type PluginInput = {
+  client: ReturnType<typeof createSynergyClient>
+  scope: {
+    type: "global" | "project"
+    id: string
+    directory: string
+    worktree: string
+    // ...other scope metadata
+  }
+  directory: string
+  worktree: string
+  serverUrl: URL
+  $: BunShell
+}
+```
+
+## Setup
+
+For an external plugin package:
+
+```bash
+bun add @ericsanchezok/synergy-plugin zod
+```
+
+Use ESM and export your plugin from your package entrypoint.
+A typical package entry might look like this:
+
+```ts
+import type { Plugin } from "@ericsanchezok/synergy-plugin"
+
+const MyPlugin: Plugin = async () => ({})
+
+export default MyPlugin
+```
+
+If you are writing a local plugin directly in a Synergy config directory such as `.synergy/plugin/` or `~/.synergy/config/plugin/`, Synergy will install `@ericsanchezok/synergy-plugin` in that config directory automatically. Any additional dependencies declared in that directory's `package.json` are installed there as well.
+
+## How plugins are loaded
+
+Synergy loads plugins from two places:
+
+### 1. Explicit plugin entries in `synergy.jsonc`
+
+The config schema includes a top-level `plugin` field:
+
+```jsonc
+{
+  "plugin": ["your-plugin-package"],
+}
+```
+
+Those entries are resolved as module specifiers and loaded by the runtime.
+Published plugin packages are installed automatically when needed.
+
+### 2. Auto-discovered local plugin files
+
+Synergy also scans these directories for `*.ts` and `*.js` files:
+
+- project scope: `<project>/.synergy/plugin/` and `<project>/.synergy/plugins/`
+- global config: `~/.synergy/config/plugin/` and `~/.synergy/config/plugins/`
+
+This makes local development straightforward:
+
+```text
+my-project/
+  .synergy/
+    plugin/
+      my-plugin.ts
+```
+
+A few practical details:
+
+- plugins are initialized in the current runtime Scope
+- every exported plugin function in a module is loaded once
+- `default` export is the safest convention unless you intentionally want multiple plugin instances from one file
+- reloading plugin state also reloads plugin-provided tools
+
+## Minimal plugin
+
+This is the smallest useful plugin: one observation hook and no custom tools.
+
+```ts
+import type { Plugin } from "@ericsanchezok/synergy-plugin"
+
+const SessionLogger: Plugin = async () => {
+  return {
+    async "session.turn.after"(input) {
+      if (input.error) {
+        console.error("session turn failed", input.sessionID, input.error)
+        return
+      }
+
+      console.log("session turn completed", input.sessionID, input.assistantMessageID)
+    },
+  }
+}
+
+export default SessionLogger
+```
+
+## Custom tools
+
+Plugins can register tools by returning a `tool` map.
+Use the `tool()` helper to define the tool schema and execution function.
+
+```ts
+import type { Plugin } from "@ericsanchezok/synergy-plugin"
+import { tool } from "@ericsanchezok/synergy-plugin/tool"
+
+const GitPlugin: Plugin = async (ctx) => {
+  return {
+    tool: {
+      current_branch: tool({
+        description: "Get the current git branch",
+        args: {},
+        async execute(_args, toolCtx) {
+          const out = await ctx.$`git rev-parse --abbrev-ref HEAD`.cwd(ctx.worktree).quiet().text()
+
+          return [`session: ${toolCtx.sessionID}`, `agent: ${toolCtx.agent}`, `branch: ${out.trim()}`].join("\n")
+        },
+      }),
+    },
+  }
+}
+
+export default GitPlugin
+```
+
+Tool execution receives a narrower context:
+
+```ts
+type ToolContext = {
+  sessionID: string
+  messageID: string
+  agent: string
+  abort: AbortSignal
+}
+```
+
+A few things to know about plugin tools:
+
+- tool args are defined with Zod shapes
+- the helper returns plain text output; Synergy wraps it into the runtime tool result format
+- long output may be truncated by the runtime, just like built-in tools
+- if you need runtime context like Scope paths or shell access, close over the outer plugin `ctx`
+
+## Hooks overview
+
+If you want a current CLI list instead of reading source, run `synergy plugin hooks` or `synergy plugin hooks --json`.
+
+Hooks fall into two broad categories.
+
+### Observation hooks
+
+These let you react to runtime events without changing the main result.
+They either have no mutable output object, or their output is not used to drive the main flow.
+
+Common examples:
+
+- `event`
+- `config`
+- `session.turn.after`
+- `cortex.task.after`
+- `agenda.run.after`
+- `agenda.run.error`
+- `engram.experience.encode.after`
+
+Use these for logging, metrics, side effects, external notifications, and indexing.
+
+### Mutation hooks
+
+These can shape what Synergy does by mutating the `output` object passed as the second argument.
+The runtime passes an object, your hook edits it in place, and the updated object continues through the pipeline.
+
+Common examples:
+
+- `chat.message`
+- `chat.params`
+- `permission.ask`
+- `tool.execute.before`
+- `tool.execute.after`
+- `agenda.run.before`
+- `note.create.before`
+- `note.update.before`
+- `note.search.before`
+- `note.search.after`
+- `engram.memory.search.before`
+- `engram.memory.search.after`
+- `experimental.*` transform hooks
+
+The rule of thumb is simple: treat `input` as context, and treat `output` as the thing you may change.
+
+## Hook reference
+
+### Core capabilities
+
+| Hook / field | Purpose                                    | Typical use                                  |
+| ------------ | ------------------------------------------ | -------------------------------------------- |
+| `tool`       | Register custom tools                      | Runtime-side integrations, project utilities |
+| `auth`       | Add provider auth methods and auth loaders | Custom providers, OAuth, API key flows       |
+| `config`     | Observe loaded config                      | Initialize plugin state from current config  |
+| `event`      | Observe bus events                         | Logging, metrics, passive integrations       |
+
+### Chat and session hooks
+
+| Hook                                   | Mutates output? | Notes                                                            |
+| -------------------------------------- | --------------- | ---------------------------------------------------------------- |
+| `chat.message`                         | Yes             | Inspect or rewrite incoming user message parts before processing |
+| `chat.params`                          | Yes             | Adjust model parameters and provider options before LLM calls    |
+| `session.turn.after`                   | No              | Observe the completed turn, including error state if present     |
+| `experimental.chat.messages.transform` | Yes             | Rewrite the message history sent to the model                    |
+| `experimental.chat.system.transform`   | Yes             | Rewrite the assembled system prompt                              |
+| `experimental.session.compacting`      | Yes             | Add compaction context or replace the compaction prompt          |
+| `experimental.text.complete`           | Yes             | Rewrite a text completion result                                 |
+
+### Permission and tool hooks
+
+| Hook                  | Mutates output? | Notes                                                   |
+| --------------------- | --------------- | ------------------------------------------------------- |
+| `permission.ask`      | Yes             | Override `ask` / `deny` / `allow` decisions             |
+| `tool.execute.before` | Yes             | Rewrite tool args before execution                      |
+| `tool.execute.after`  | Yes             | Rewrite tool output, title, or metadata after execution |
+
+### Cortex and agenda hooks
+
+| Hook                | Mutates output? | Notes                                                     |
+| ------------------- | --------------- | --------------------------------------------------------- |
+| `cortex.task.after` | No              | Observe completed Cortex task execution                   |
+| `agenda.run.before` | Yes             | Skip a run or replace the `AgendaItem` used for execution |
+| `agenda.run.after`  | No              | Observe a successful agenda run                           |
+| `agenda.run.error`  | No              | Observe a failed agenda run                               |
+
+### Note hooks
+
+| Hook                 | Mutates output? | Notes                                                               |
+| -------------------- | --------------- | ------------------------------------------------------------------- |
+| `note.create.before` | Yes             | Rewrite note creation input before storage                          |
+| `note.create.after`  | Usually no      | Observe the created note after persistence                          |
+| `note.update.before` | Yes             | Rewrite the patch before update logic runs                          |
+| `note.update.after`  | Usually no      | Observe the updated note after persistence                          |
+| `note.search.before` | Yes             | Rewrite search pattern, scope, date filters, tags, or pinned filter |
+| `note.search.after`  | Yes             | Filter or reorder returned notes                                    |
+
+### Engram hooks
+
+| Hook                             | Mutates output? | Notes                                                                      |
+| -------------------------------- | --------------- | -------------------------------------------------------------------------- |
+| `engram.memory.search.before`    | Yes             | Rewrite query, vector, top-k, categories, recall modes, or rerank behavior |
+| `engram.memory.search.after`     | Yes             | Filter or rerank returned engram memory results                            |
+| `engram.experience.encode.after` | No              | Observe whether an experience was encoded, skipped, or deduplicated        |
+
+### Experimental hooks
+
+Hooks under `experimental.*` are available, but they are less stable than the core hook surface. Use them when you need them, but expect them to evolve more quickly than the main plugin API.
+
+## Short example
+
+This example combines a custom tool with two hooks:
+
+- `session.turn.after` for observation
+- `note.search.after` for result shaping
+
+```ts
+import type { Plugin } from "@ericsanchezok/synergy-plugin"
+import { tool } from "@ericsanchezok/synergy-plugin/tool"
+
+const ExamplePlugin: Plugin = async (ctx) => {
+  return {
+    tool: {
+      scope_info: tool({
+        description: "Show the current Scope and worktree",
+        args: {},
+        async execute() {
+          return [
+            `scope: ${ctx.scope.id}`,
+            `scopeType: ${ctx.scope.type}`,
+            `directory: ${ctx.directory}`,
+            `worktree: ${ctx.worktree}`,
+          ].join("\n")
+        },
+      }),
+    },
+
+    async "session.turn.after"(input) {
+      if (!input.error) {
+        console.log("assistant replied in session", input.sessionID)
+      }
+    },
+
+    async "note.search.after"(_input, output) {
+      output.notes = output.notes.filter((note) => !note.tags.includes("private"))
+    },
+  }
+}
+
+export default ExamplePlugin
+```
+
+## Best practices
+
+### Keep hooks fast
+
+Most hooks run inline with real user work. If a hook blocks, the user feels it.
+Do the minimum in the hook path. Push slow work to another system when possible.
+
+### Be conservative with mutation
+
+If you mutate an output object, make the change narrow and obvious.
+A good plugin should be easy to reason about six months later.
+
+### Treat Scope as real context
+
+Plugins run inside a resolved Scope. Prefer `ctx.scope`, `ctx.directory`, and `ctx.worktree` over guessing from process state.
+
+### Use `ctx.$` carefully
+
+`ctx.$` is useful for local runtime-side commands, but it also makes it easy to couple a plugin to one machine or one repository layout. Shell out when that is the simplest correct answer, not by default.
+
+### Prefer observation hooks for telemetry and indexing
+
+If you only need to watch what happened, use an after-hook or `event` hook instead of intercepting earlier stages.
+
+### Be explicit about note and engram behavior
+
+Hooks like `note.search.after` and `engram.memory.search.after` can quietly change what users see. Document those policies in the plugin itself and keep them predictable.
+
+### Expect experimental hooks to move
+
+If your plugin depends on an `experimental.*` hook, isolate that logic so future API changes are easy to update.
+
+### Export one plugin by default
+
+A single default export keeps module behavior obvious. Multiple exported plugin functions are supported, but they are loaded independently.
+
+## Auth plugins
+
+A plugin can also provide `auth` for a custom provider. That is how plugins participate in provider-specific API key or OAuth flows and, when needed, compute provider options through an auth loader.
+
+If you only need custom tools or hooks, you can ignore `auth` entirely.
+
+## When to use a plugin vs other extension points
+
+Use a plugin when you need runtime behavior:
+
+- add a tool
+- intercept a session, agenda, note, or engram lifecycle step
+- integrate provider auth
+- react to runtime events
+
+Use other extension points when the problem is simpler:
+
+- use `.synergy/command/` for reusable prompt commands
+- use `.synergy/skill/` for domain instructions and workflows
+- use config in `synergy.jsonc` for static runtime configuration
+
+## Development notes
+
+- local plugin files can live under `.synergy/plugin/` or `.synergy/plugins/`
+- global plugin files can live under `~/.synergy/config/plugin/` or `~/.synergy/config/plugins/`
+- explicit package plugins can be listed in `synergy.jsonc` under `plugin`
+- plugin reload also refreshes plugin-provided tools
+
+That is the core model: a plugin is an async server-side module that receives runtime context, returns hooks and tools, and participates directly in Scope-aware execution.

package/dist/example.d.ts

@@ -1,2 +1,3 @@
 import { Plugin } from "./index";
 export declare const ExamplePlugin: Plugin;
+export default ExamplePlugin;

package/dist/example.js

@@ -1,16 +1,88 @@
 import { tool } from "./tool";
+const MAX_NOTE_TAGS = 8;
+const AUTO_TAG = "reference-plugin";
+function normalizeTag(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/g, "-")
+        .replace(/[^a-z0-9:_-]/g, "");
+}
+function mergeTags(tags) {
+    const unique = new Set();
+    for (const tag of tags ?? []) {
+        const normalized = normalizeTag(tag);
+        if (normalized)
+            unique.add(normalized);
+        if (unique.size >= MAX_NOTE_TAGS)
+            break;
+    }
+    unique.add(AUTO_TAG);
+    return Array.from(unique).slice(0, MAX_NOTE_TAGS);
+}
+function preview(text, limit = 160) {
+    const singleLine = text.replace(/\s+/g, " ").trim();
+    if (singleLine.length <= limit)
+        return singleLine;
+    return `${singleLine.slice(0, limit - 1)}…`;
+}
 export const ExamplePlugin = async (ctx) => {
+    const logger = ctx.$.env({ SYNERGY_LOG_LEVEL: "warn" });
     return {
         tool: {
-            mytool: tool({
-                description: "This is a custom tool",
+            workspace_summary: tool({
+                description: "Summarize the active Synergy plugin runtime context",
                 args: {
-                    foo: tool.schema.string().describe("foo"),
+                    includeDirectorySample: tool.schema.boolean().optional().describe("Include a short directory listing sample"),
                 },
-                async execute(args) {
-                    return `Hello ${args.foo}!`;
+                async execute(args, context) {
+                    const lines = [
+                        `scope: ${ctx.scope.type}:${ctx.scope.id}`,
+                        `directory: ${ctx.directory}`,
+                        `worktree: ${ctx.worktree}`,
+                        `server: ${ctx.serverUrl.toString()}`,
+                        `session: ${context.sessionID}`,
+                        `agent: ${context.agent}`,
+                    ];
+                    if (args.includeDirectorySample) {
+                        const result = await logger `ls`;
+                        const sample = result
+                            .text()
+                            .split("\n")
+                            .map((line) => line.trim())
+                            .filter(Boolean)
+                            .slice(0, 10);
+                        if (sample.length > 0) {
+                            lines.push(`entries: ${sample.join(", ")}`);
+                        }
+                    }
+                    return lines.join("\n");
                 },
             }),
         },
+        async "session.turn.after"(input) {
+            const status = input.error ? "error" : (input.finish ?? "unknown");
+            const summary = {
+                sessionID: input.sessionID,
+                assistantMessageID: input.assistantMessageID,
+                agent: input.assistant.agent,
+                finish: status,
+            };
+            console.info("[example-plugin] session.turn.after", summary);
+        },
+        async "note.create.before"(_, output) {
+            output.note.title = output.note.title.trim() || "Untitled note";
+            output.note.tags = mergeTags(output.note.tags);
+            if (!output.note.contentText?.trim()) {
+                output.note.contentText = preview(output.note.title);
+            }
+        },
+        async "engram.memory.search.after"(input, output) {
+            output.results = output.results
+                .slice()
+                .sort((left, right) => right.similarity - left.similarity)
+                .slice(0, input.topK);
+        },
     };
 };
+export default ExamplePlugin;

package/dist/hooks.d.ts

@@ -0,0 +1,9 @@
+export type HookCategory = "core" | "chat" | "permission" | "tool" | "session" | "cortex" | "agenda" | "note" | "engram" | "experimental";
+export interface HookDescriptor {
+    name: string;
+    category: HookCategory;
+    mutatesOutput: boolean;
+    summary: string;
+}
+export declare const HOOKS: HookDescriptor[];
+export declare const HOOK_CATEGORIES: HookCategory[];

package/dist/hooks.js

@@ -0,0 +1,176 @@
+export const HOOKS = [
+    {
+        name: "tool",
+        category: "core",
+        mutatesOutput: false,
+        summary: "Register custom runtime-side tools",
+    },
+    {
+        name: "auth",
+        category: "core",
+        mutatesOutput: false,
+        summary: "Add provider auth methods and auth loaders",
+    },
+    {
+        name: "config",
+        category: "core",
+        mutatesOutput: false,
+        summary: "Observe the loaded runtime config",
+    },
+    {
+        name: "event",
+        category: "core",
+        mutatesOutput: false,
+        summary: "Observe runtime bus events",
+    },
+    {
+        name: "chat.message",
+        category: "chat",
+        mutatesOutput: true,
+        summary: "Rewrite incoming user messages before processing",
+    },
+    {
+        name: "chat.params",
+        category: "chat",
+        mutatesOutput: true,
+        summary: "Adjust model parameters before LLM calls",
+    },
+    {
+        name: "permission.ask",
+        category: "permission",
+        mutatesOutput: true,
+        summary: "Override ask, deny, or allow decisions",
+    },
+    {
+        name: "tool.execute.before",
+        category: "tool",
+        mutatesOutput: true,
+        summary: "Rewrite tool args before execution",
+    },
+    {
+        name: "tool.execute.after",
+        category: "tool",
+        mutatesOutput: true,
+        summary: "Rewrite tool output, title, or metadata",
+    },
+    {
+        name: "session.turn.after",
+        category: "session",
+        mutatesOutput: false,
+        summary: "Observe completed assistant turns",
+    },
+    {
+        name: "cortex.task.after",
+        category: "cortex",
+        mutatesOutput: false,
+        summary: "Observe completed Cortex tasks",
+    },
+    {
+        name: "agenda.run.before",
+        category: "agenda",
+        mutatesOutput: true,
+        summary: "Skip or rewrite an agenda run before execution",
+    },
+    {
+        name: "agenda.run.after",
+        category: "agenda",
+        mutatesOutput: false,
+        summary: "Observe successful agenda runs",
+    },
+    {
+        name: "agenda.run.error",
+        category: "agenda",
+        mutatesOutput: false,
+        summary: "Observe failed agenda runs",
+    },
+    {
+        name: "note.create.before",
+        category: "note",
+        mutatesOutput: true,
+        summary: "Rewrite note creation input before persistence",
+    },
+    {
+        name: "note.create.after",
+        category: "note",
+        mutatesOutput: false,
+        summary: "Observe created notes after persistence",
+    },
+    {
+        name: "note.update.before",
+        category: "note",
+        mutatesOutput: true,
+        summary: "Rewrite note patches before update logic runs",
+    },
+    {
+        name: "note.update.after",
+        category: "note",
+        mutatesOutput: false,
+        summary: "Observe updated notes after persistence",
+    },
+    {
+        name: "note.search.before",
+        category: "note",
+        mutatesOutput: true,
+        summary: "Rewrite note search filters before execution",
+    },
+    {
+        name: "note.search.after",
+        category: "note",
+        mutatesOutput: true,
+        summary: "Filter or reorder note search results",
+    },
+    {
+        name: "engram.memory.search.before",
+        category: "engram",
+        mutatesOutput: true,
+        summary: "Rewrite engram memory search query and options",
+    },
+    {
+        name: "engram.memory.search.after",
+        category: "engram",
+        mutatesOutput: true,
+        summary: "Filter or reorder engram memory results",
+    },
+    {
+        name: "engram.experience.encode.after",
+        category: "engram",
+        mutatesOutput: false,
+        summary: "Observe experience encoding outcomes",
+    },
+    {
+        name: "experimental.chat.messages.transform",
+        category: "experimental",
+        mutatesOutput: true,
+        summary: "Rewrite the chat message history sent to the model",
+    },
+    {
+        name: "experimental.chat.system.transform",
+        category: "experimental",
+        mutatesOutput: true,
+        summary: "Rewrite the assembled system prompt",
+    },
+    {
+        name: "experimental.session.compacting",
+        category: "experimental",
+        mutatesOutput: true,
+        summary: "Customize session compaction context or prompt",
+    },
+    {
+        name: "experimental.text.complete",
+        category: "experimental",
+        mutatesOutput: true,
+        summary: "Rewrite text completion output before finalization",
+    },
+];
+export const HOOK_CATEGORIES = [
+    "core",
+    "chat",
+    "permission",
+    "tool",
+    "session",
+    "cortex",
+    "agenda",
+    "note",
+    "engram",
+    "experimental",
+];

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import type { Event, createSynergyClient, Model, Provider, PermissionRequest, UserMessage, Message, Part, Auth, Config } from "@ericsanchezok/synergy-sdk";
+import type { AgendaItem, AgendaRunLog, CortexTask, Event, createSynergyClient, MemoryCategory, MemoryRecallMode, MemorySearchResult, Model, NoteCreateInput, NoteInfo, NotePatchInput, Provider, PermissionRequest, UserMessage, Message, Part, Auth, Config } from "@ericsanchezok/synergy-sdk";
 import type { BunShell } from "./shell";
 import { type ToolDefinition } from "./tool";
 export * from "./tool";
@@ -208,4 +208,114 @@ export interface Hooks {
     }, output: {
         text: string;
     }) => Promise<void>;
+    "session.turn.after"?: (input: {
+        sessionID: string;
+        userMessageID: string;
+        assistantMessageID: string;
+        assistant: Message;
+        finish?: string;
+        error?: unknown;
+    }, output: {}) => Promise<void>;
+    "cortex.task.after"?: (input: {
+        task: CortexTask;
+    }, output: {}) => Promise<void>;
+    "agenda.run.before"?: (input: {
+        signal: {
+            type: string;
+            source: string;
+            payload?: Record<string, unknown>;
+            timestamp: number;
+        };
+        item: AgendaItem;
+        scopeID: string;
+    }, output: {
+        skip: boolean;
+        item: AgendaItem;
+    }) => Promise<void>;
+    "agenda.run.after"?: (input: {
+        signal: {
+            type: string;
+            source: string;
+            payload?: Record<string, unknown>;
+            timestamp: number;
+        };
+        item: AgendaItem;
+        run: AgendaRunLog;
+        scopeID: string;
+    }, output: {}) => Promise<void>;
+    "agenda.run.error"?: (input: {
+        signal: {
+            type: string;
+            source: string;
+            payload?: Record<string, unknown>;
+            timestamp: number;
+        };
+        item: AgendaItem;
+        scopeID: string;
+        error: string;
+        sessionID?: string;
+    }, output: {}) => Promise<void>;
+    "note.create.before"?: (input: {
+        scopeID: string;
+    }, output: {
+        note: NoteCreateInput;
+    }) => Promise<void>;
+    "note.create.after"?: (input: {
+        scopeID: string;
+        noteID: string;
+    }, output: {
+        note: NoteInfo;
+    }) => Promise<void>;
+    "note.update.before"?: (input: {
+        scopeID: string;
+        noteID: string;
+        current: NoteInfo;
+    }, output: {
+        patch: NotePatchInput;
+    }) => Promise<void>;
+    "note.update.after"?: (input: {
+        scopeID: string;
+        noteID: string;
+    }, output: {
+        note: NoteInfo;
+    }) => Promise<void>;
+    "note.search.before"?: (input: {
+        scopeID: string;
+    }, output: {
+        pattern: string;
+        scope: "current" | "global" | "all";
+        since?: string;
+        before?: string;
+        tags?: string[];
+        pinned?: boolean;
+    }) => Promise<void>;
+    "note.search.after"?: (input: {
+        scopeID: string;
+        pattern: string;
+    }, output: {
+        notes: NoteInfo[];
+    }) => Promise<void>;
+    "engram.memory.search.before"?: (input: {}, output: {
+        query: string;
+        vector?: number[];
+        topK?: number;
+        categories?: MemoryCategory[];
+        recallModes?: MemoryRecallMode[];
+        rerank?: boolean;
+    }) => Promise<void>;
+    "engram.memory.search.after"?: (input: {
+        query: string;
+        topK: number;
+    }, output: {
+        results: MemorySearchResult[];
+    }) => Promise<void>;
+    "engram.experience.encode.after"?: (input: {
+        sessionID: string;
+        userMessageID: string;
+    }, output: {
+        encoded: boolean;
+        skipped: boolean;
+        duplicateOf?: string;
+        experienceID?: string;
+    }) => Promise<void>;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@ericsanchezok/synergy-plugin",
-  "version": "1.1.28",
+  "version": "1.2.1",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -24,6 +24,10 @@
     "./tool": {
       "import": "./dist/tool.js",
       "types": "./dist/tool.d.ts"
+    },
+    "./hooks": {
+      "import": "./dist/hooks.js",
+      "types": "./dist/hooks.d.ts"
     }
   },
   "files": [