akm-opencode 0.2.0 → 0.4.1

package/README.md

@@ -1,6 +1,6 @@
 # akm-opencode
 
-OpenCode plugin for the [Agentikit](https://github.com/itlackey/agentikit) CLI. Registers tools that let your AI agent **search**, **show**, and **manage** extension assets from stash directories and registries.
+OpenCode plugin for the [AKM](https://github.com/itlackey/akm) CLI. Registers tools that let your AI agent **search**, **show**, and **manage** extension assets from stash directories and registries — plus **agentic hooks** that auto-load relevant assets into each turn, record feedback when assets are used, and harvest session memories so the stash improves with every session.
 
 ## Installation
 
@@ -23,14 +23,53 @@ Add to your OpenCode config (`opencode.json`):
 | `akm_agent` | Dispatch a stash `agent:*` into OpenCode using the stash prompt and metadata |
 | `akm_cmd` | Execute a stash `command:*` template in OpenCode via SDK session prompting |
 | `akm_add` | Install kits from npm, GitHub, git URLs, or local directories |
-| `akm_list` | List installed registry kits |
-| `akm_remove` | Remove an installed registry kit and reindex |
-| `akm_update` | Update one installed kit or all installed kits |
+| `akm_list` | List configured AKM sources |
+| `akm_remove` | Remove a configured AKM source and reindex |
+| `akm_update` | Update one managed source or all managed sources |
 | `akm_clone` | Clone an asset into the working stash or a custom destination for editing |
+| `akm_remember` | Record a memory in the default stash |
+| `akm_feedback` | Record positive or negative feedback for a stash asset |
 | `akm_config` | Get, set, unset, list, or inspect akm configuration (including `config path --all`) |
 | `akm_run` | Execute a stash script using its `run` field |
-| `akm_sources` | List all resolved stash search paths |
+| `akm_sources` | Backward-compatible alias that lists configured AKM sources |
 | `akm_upgrade` | Check for or install akm CLI updates |
+| `akm_curate` | Curate the stash for a task or topic and return ranked matches the agent can use |
+| `akm_evolve` | Dispatch the AKM curator agent to review recent session activity and propose stash improvements |
+
+## Compound-engineering hooks
+
+The plugin subscribes to OpenCode lifecycle events so AKM participates in the
+session loop instead of waiting to be called. Every hook is non-blocking and
+fails silently when `akm` is not on PATH — the TUI is never affected.
+
+| Event | What happens |
+| --- | --- |
+| **`session.created`** (event hook) | Warms the stash index in the background and caches `akm hints` for the next system transform so the agent knows the CLI surface area at turn 0. |
+| **`chat.message`** | Runs `akm curate "<prompt>"` on each user message (prompts shorter than `AKM_CURATE_MIN_CHARS` are skipped). The top matches are stored for injection. Memory intents (prompts mentioning "remember" / "memory") are tracked in the session buffer. |
+| **`experimental.chat.system.transform`** | Appends the cached hints (once per session) and the curated context (once per turn) to the model's system prompt so the agent sees relevant stash assets before answering. |
+| **`tool.execute.after`** (`akm_*` tools) | Logs asset usage, accumulates refs into the session buffer, and records `akm feedback <ref> --positive` / `--negative` automatically based on whether the tool succeeded or failed. Never recurses into `akm_feedback` and skips `memory:` refs. |
+| **`stop`** / **`session.idle`** / **`session.compacted`** / **`session.deleted`** | Flushes the per-session buffer into a `memory:opencode-session-YYYYMMDD-<sid>` memory so every meaningful session contributes durable context for future searches. Requires at least two observations before persisting. |
+
+### Environment overrides
+
+| Variable | Default | Purpose |
+| --- | --- | --- |
+| `AKM_AUTO_CURATE` | `1` | Set to `0` to disable automatic `akm curate` on user messages. |
+| `AKM_AUTO_FEEDBACK` | `1` | Set to `0` to disable automatic `akm feedback` on tool success/failure. |
+| `AKM_AUTO_HINTS` | `1` | Set to `0` to skip injecting `akm hints` at session start. |
+| `AKM_AUTO_MEMORY` | `1` | Set to `0` to disable automatic session-summary memories. |
+| `AKM_CURATE_LIMIT` | `5` | Max curated results injected into context per prompt. |
+| `AKM_CURATE_MIN_CHARS` | `16` | Minimum prompt length before curation runs. |
+| `AKM_CURATE_TIMEOUT` | `8` | Wall-clock seconds for `akm` invocations inside hooks. |
+
+### Curator agent
+
+`akm_evolve` dispatches a child OpenCode session running a built-in curator
+prompt that reviews recent AKM activity (OpenCode app logs, session-summary
+memories, live stash) and produces a prioritized action list: hot assets to
+promote, cold ones to investigate, coverage gaps to draft, duplicates to
+consolidate. The curator never applies destructive changes without explicit
+user approval.
 
 ### Registry discovery
 
@@ -79,9 +118,9 @@ When the plugin loads, it runs `bun install -g akm-cli@latest` so it always pick
 
 ```sh
 # macOS / Linux
-curl -fsSL https://raw.githubusercontent.com/itlackey/agentikit/main/install.sh | bash
+curl -fsSL https://raw.githubusercontent.com/itlackey/akm/main/install.sh | bash
 # PowerShell (Windows)
-irm https://raw.githubusercontent.com/itlackey/agentikit/main/install.ps1 -OutFile install.ps1; ./install.ps1
+irm https://raw.githubusercontent.com/itlackey/akm/main/install.ps1 -OutFile install.ps1; ./install.ps1
 
 # Or via Bun
 bun install -g akm-cli@latest
@@ -110,6 +149,6 @@ Assets are resolved from three source types: **working** (local stash), **search
 
 ## Docs
 
-- [Agentikit CLI](https://github.com/itlackey/agentikit)
+- [AKM CLI](https://github.com/itlackey/akm)
 - [OpenCode Plugins](https://opencode.ai/docs/plugins/)
 - [OpenCode Custom Tools](https://opencode.ai/docs/custom-tools/)

package/index.ts

@@ -5,6 +5,71 @@ import path from "node:path"
 let resolvedAkmCommand = "akm"
 const autoInstallPackageRef = "akm-cli@latest"
 
+const AKM_AUTO_FEEDBACK = (process.env.AKM_AUTO_FEEDBACK ?? "1") !== "0"
+const AKM_AUTO_MEMORY = (process.env.AKM_AUTO_MEMORY ?? "1") !== "0"
+const AKM_AUTO_CURATE = (process.env.AKM_AUTO_CURATE ?? "1") !== "0"
+const AKM_AUTO_HINTS = (process.env.AKM_AUTO_HINTS ?? "1") !== "0"
+const AKM_CURATE_LIMIT = Math.max(1, Number(process.env.AKM_CURATE_LIMIT ?? "5") || 5)
+const AKM_CURATE_MIN_CHARS = Math.max(1, Number(process.env.AKM_CURATE_MIN_CHARS ?? "16") || 16)
+const AKM_CURATE_TIMEOUT_MS = Math.max(1_000, (Number(process.env.AKM_CURATE_TIMEOUT ?? "8") || 8) * 1_000)
+
+// Per-session state that drives the compound-engineering loop.
+// These maps are keyed by OpenCode sessionID.
+const sessionHints = new Map<string, string>()
+const sessionCurated = new Map<string, string>()
+type SessionBufferEntry = {
+  timestamp: string
+  kind: "memory-intent" | "tool-ref"
+  toolName?: string
+  ref?: string
+  status?: "positive" | "negative" | "unknown"
+  note?: string
+}
+const sessionBuffer = new Map<string, SessionBufferEntry[]>()
+const sessionMemoryCaptured = new Set<string>()
+
+// Asset-ref grammar matching the stash skill: [origin//]type:name
+const AKM_REF_PATTERN = /(?:[A-Za-z0-9@._+/-]+\/\/)?(?:skill|command|agent|knowledge|memory|script):[A-Za-z0-9._/\-]+/g
+
+const CURATOR_AGENT_PROMPT = `You are the AKM curator — a compound-engineering agent that keeps the user's AKM stash improving every time the main agent finishes a task.
+
+Inputs you should inspect:
+1. OpenCode app logs that include the "akm-opencode" service (feedback, memory, tool invocations).
+2. Session-summary memories named memory:opencode-session-*.
+3. The live stash: call akm_list, akm_search "" --limit 50, and akm_show <ref>.
+
+Signals to act on:
+- Hot refs: assets repeatedly appearing in positive tool outcomes. Call akm_feedback <ref> positive --note "curator: consistently useful" to reinforce.
+- Cold refs: assets tied to failures or user complaints. Record akm_feedback <ref> negative --note "<excerpt>" and open the asset for review.
+- Missing coverage: recurring user prompts with no matching asset. Draft a new skill, command, or knowledge doc in the working stash and reindex with akm_index.
+- Duplicates / drift: near-identical descriptions or overlapping responsibilities. Propose a consolidation.
+- Stale memories: session summaries that never get recalled. Propose akm_remove memory:<name> once distilled into a durable knowledge doc.
+
+Rules of engagement:
+- Never apply destructive changes without explicit user approval.
+- Report findings as a prioritized action list of concrete akm_* tool calls the user can run.
+- Prefer small, reversible edits: promote via positive feedback, draft a candidate skill, or clone and tweak.
+- When drafting new assets, write them into the working stash directory (akm_config get stashDir) under skills/, commands/, agents/, knowledge/, or scripts/. Call akm_index when finished.
+- When finished, persist your own summary with akm_remember (name: curator-run-<timestamp>) so the next curator run can build on yours.
+
+Output shape: end every run with a markdown report that has these sections:
+
+## Hot assets (promote)
+- <ref> — why it helped — command to run
+
+## Cold assets (investigate)
+- <ref> — failure signal — proposed fix
+
+## Coverage gaps
+- <theme> — proposed asset (type, name, one-line description)
+
+## Duplicates / drift
+- <ref a> vs <ref b> — consolidation proposal
+
+## Housekeeping
+- stale memories, reindex needs, config tweaks
+`
+
 type LogLevel = "debug" | "info" | "warn" | "error"
 
 type LogCapableClient = {
@@ -29,7 +94,7 @@ type CliLogMeta = {
 
 function formatCliError(error: unknown): string {
   if (error && typeof error === "object" && "code" in error && (error as { code?: unknown }).code === "ENOENT") {
-    return "The 'akm' CLI was not found on PATH. Install it first from https://github.com/itlackey/agentikit."
+    return "The 'akm' CLI was not found on PATH. Install it first from https://github.com/itlackey/akm."
   }
   return error instanceof Error ? error.message : String(error)
 }
@@ -62,6 +127,209 @@ async function writePluginLog(client: LogCapableClient, level: LogLevel, message
   }
 }
 
+function nowIso(): string {
+  return new Date().toISOString()
+}
+
+function addBufferEntry(sessionID: string | undefined, entry: Omit<SessionBufferEntry, "timestamp">) {
+  if (!sessionID) return
+  const buf = sessionBuffer.get(sessionID) ?? []
+  buf.push({ timestamp: nowIso(), ...entry })
+  sessionBuffer.set(sessionID, buf)
+}
+
+// Synchronous CLI invocation used by the lifecycle hooks — the plugin host does
+// not await these in a hot path, but we still cap execution time so a slow
+// stash never wedges the session loop.
+function runCliSyncRaw(args: string[], timeoutMs: number): { ok: true; stdout: string } | { ok: false; error: string } {
+  const command = resolveAkmCommand()
+  if (typeof command !== "string") return { ok: false, error: command.error }
+  try {
+    const stdout = execFileSync(command, args, {
+      encoding: "utf8",
+      timeout: timeoutMs,
+      stdio: ["ignore", "pipe", "pipe"],
+    })
+    return { ok: true, stdout }
+  } catch (error: unknown) {
+    return { ok: false, error: formatCliError(error) }
+  }
+}
+
+function runCurateForPrompt(text: string): string | null {
+  if (!text || text.length < AKM_CURATE_MIN_CHARS) return null
+  const result = runCliSyncRaw(
+    [
+      "--for-agent",
+      "--format",
+      "text",
+      "--detail",
+      "summary",
+      "-q",
+      "curate",
+      text,
+      "--limit",
+      String(AKM_CURATE_LIMIT),
+    ],
+    AKM_CURATE_TIMEOUT_MS,
+  )
+  if (!result.ok) return null
+  const body = result.stdout.trim()
+  return body || null
+}
+
+function runHintsForSession(): string | null {
+  const result = runCliSyncRaw(["--format", "text", "-q", "hints"], AKM_CURATE_TIMEOUT_MS)
+  if (!result.ok) return null
+  const body = result.stdout.trim()
+  return body || null
+}
+
+function warmIndexInBackground(): void {
+  const command = resolveAkmCommand()
+  if (typeof command !== "string") return
+  try {
+    // Fire and forget — execSync with a timeout would block, so spawn via the
+    // shell and detach. Errors here are never surfaced to the session.
+    execSync(`${JSON.stringify(command)} index >/dev/null 2>&1 &`, { timeout: 2_000 })
+  } catch {
+    // Intentionally ignore — warming is best-effort.
+  }
+}
+
+function recordFeedbackSync(ref: string, sentiment: "positive" | "negative", note: string): boolean {
+  const result = runCliSyncRaw(
+    [
+      "--format",
+      "json",
+      "-q",
+      "feedback",
+      ref,
+      sentiment === "positive" ? "--positive" : "--negative",
+      "--note",
+      note,
+    ],
+    AKM_CURATE_TIMEOUT_MS,
+  )
+  return result.ok
+}
+
+function captureSessionMemory(sessionID: string, reason: string): string | null {
+  if (!AKM_AUTO_MEMORY) return null
+  if (!sessionID) return null
+  if (sessionMemoryCaptured.has(sessionID)) return null
+  const entries = sessionBuffer.get(sessionID) ?? []
+  // Require at least two observations before persisting — single events are noise.
+  if (entries.length < 2) {
+    sessionBuffer.delete(sessionID)
+    return null
+  }
+
+  const lines: string[] = []
+  lines.push(`# Session summary (${nowIso()})`)
+  lines.push(`Reason: ${reason}`)
+  lines.push(`Session: ${sessionID}`)
+  lines.push("")
+  for (const entry of entries) {
+    if (entry.kind === "memory-intent") {
+      lines.push(`## ${entry.timestamp} — user memory intent`)
+      if (entry.note) lines.push(entry.note)
+      lines.push("")
+    } else {
+      lines.push(`## ${entry.timestamp} — ${entry.toolName ?? "tool"} ${entry.status ?? "unknown"}`)
+      if (entry.ref) lines.push(`- ref: ${entry.ref}`)
+      if (entry.note) lines.push(`- note: ${entry.note}`)
+      lines.push("")
+    }
+  }
+  const body = lines.join("\n")
+
+  const dateTag = new Date().toISOString().replace(/[-:]/g, "").slice(0, 8)
+  const shortSid = sessionID.replace(/[^A-Za-z0-9._-]/g, "").slice(0, 8) || "session"
+  const name = `opencode-session-${dateTag}-${shortSid}`
+
+  const command = resolveAkmCommand()
+  if (typeof command !== "string") {
+    sessionMemoryCaptured.add(sessionID)
+    sessionBuffer.delete(sessionID)
+    return null
+  }
+  try {
+    execFileSync(command, ["--format", "json", "-q", "remember", "--name", name, "--force"], {
+      encoding: "utf8",
+      timeout: AKM_CURATE_TIMEOUT_MS * 2,
+      input: body,
+    })
+    sessionMemoryCaptured.add(sessionID)
+    sessionBuffer.delete(sessionID)
+    return `memory:${name}`
+  } catch {
+    sessionMemoryCaptured.add(sessionID)
+    sessionBuffer.delete(sessionID)
+    return null
+  }
+}
+
+function extractToolRefs(toolName: string, args: Record<string, unknown>, output: unknown): string[] {
+  const refs = new Set<string>()
+  const addMatches = (value: unknown) => {
+    if (typeof value !== "string") return
+    const matches = value.match(AKM_REF_PATTERN)
+    if (matches) for (const ref of matches) refs.add(ref)
+  }
+
+  for (const key of ["ref", "package_ref"]) {
+    addMatches((args as Record<string, unknown>)[key])
+  }
+
+  if (output && typeof output === "object") {
+    const o = output as Record<string, unknown>
+    addMatches(o.ref)
+    if (Array.isArray(o.hits)) {
+      for (const hit of o.hits) {
+        if (hit && typeof hit === "object") addMatches((hit as Record<string, unknown>).ref)
+      }
+    }
+    if (Array.isArray(o.assetHits)) {
+      for (const hit of o.assetHits) {
+        if (hit && typeof hit === "object") addMatches((hit as Record<string, unknown>).ref)
+      }
+    }
+    if (toolName === "akm_remember" && typeof o.ref === "string") addMatches(o.ref)
+  }
+
+  return [...refs]
+}
+
+const AKM_HINTS_PREFIX = [
+  "# AKM is available in this session",
+  "",
+  "You have an AKM stash on this machine. Before writing anything from scratch, call `akm_search` or `akm_curate` to see if the stash already covers it. Record `akm_feedback <ref> positive|negative` whenever an asset materially helps or misses, and use `akm_remember` to persist durable learnings so future sessions inherit them.",
+].join("\n")
+
+const AKM_CURATED_HEADER = "# AKM stash — assets relevant to this prompt"
+const AKM_CURATED_TAIL = "\n\nTip: call `akm_show <ref>` to fetch full content, and record `akm_feedback <ref> positive|negative` once you know whether the asset helped."
+
+function extractSessionIdFromEvent(payload: unknown): string | undefined {
+  if (!payload || typeof payload !== "object") return undefined
+  const p = payload as Record<string, unknown>
+  const candidates = [
+    p.sessionID,
+    p.session_id,
+    p.session,
+    (p.session as Record<string, unknown> | undefined)?.id,
+    (p.properties as Record<string, unknown> | undefined)?.sessionID,
+    (p.properties as Record<string, unknown> | undefined)?.session_id,
+    (p.properties as Record<string, unknown> | undefined)?.id,
+    (p.info as Record<string, unknown> | undefined)?.id,
+    (p.info as Record<string, unknown> | undefined)?.sessionID,
+  ]
+  for (const value of candidates) {
+    if (typeof value === "string" && value) return value
+  }
+  return undefined
+}
+
 function getCommandStatus(command: string): "ok" | "missing" | "error" {
   try {
     execFileSync(command, ["--version"], {
@@ -154,7 +422,7 @@ function resolveAkmCommand(): string | CliError {
 
   return {
     ok: false,
-    error: `The 'akm' CLI could not be resolved after attempting to install '${autoInstallPackageRef}' with Bun. Install akm from https://github.com/itlackey/agentikit.`,
+    error: `The 'akm' CLI could not be resolved after attempting to install '${autoInstallPackageRef}' with Bun. Install akm from https://github.com/itlackey/akm.`,
   }
 }
 
@@ -212,7 +480,7 @@ async function runCli(client: LogCapableClient, args: string[], meta: CliLogMeta
 }
 
 type CliError = { ok: false; error: string }
-type AssetType = "skill" | "command" | "agent" | "knowledge" | "script"
+type AssetType = "agent" | "command" | "knowledge" | "memory" | "script" | "skill"
 
 type ShowAgentResponse = {
   type: "agent"
@@ -276,7 +544,7 @@ type SearchHit = {
 
 type SearchResponse = {
   hits?: SearchHit[]
-  source?: "local" | "registry" | "both"
+  source?: "local" | "stash" | "registry" | "both"
   stashDir?: string
   timing?: { totalMs?: number; rankMs?: number; embedMs?: number }
   warnings?: string[]
@@ -376,6 +644,59 @@ function extractText(parts: unknown): string {
   return segments.join("\n\n")
 }
 
+function parseToolOutput(raw: string): unknown {
+  try {
+    return JSON.parse(raw)
+  } catch {
+    return undefined
+  }
+}
+
+function extractMemoryRefs(toolName: string, args: Record<string, unknown>, value: unknown): string[] {
+  const refs = new Set<string>()
+  const parsed = value && typeof value === "object" ? value as {
+    type?: unknown
+    ref?: unknown
+    name?: unknown
+    hits?: unknown
+  } : undefined
+
+  if (toolName === "akm_remember" && typeof parsed?.ref === "string" && parsed.ref) {
+    refs.add(parsed.ref)
+  }
+
+  if (parsed?.type === "memory") {
+    if (typeof parsed.ref === "string" && parsed.ref) refs.add(parsed.ref)
+    if (typeof args.ref === "string" && args.ref) refs.add(args.ref)
+    if (refs.size === 0 && typeof parsed.name === "string" && parsed.name) refs.add(`memory:${parsed.name}`)
+  }
+
+  if (Array.isArray(parsed?.hits)) {
+    for (const hit of parsed.hits) {
+      if (!hit || typeof hit !== "object") continue
+      if ((hit as { type?: unknown }).type !== "memory") continue
+      const ref = (hit as { ref?: unknown }).ref
+      if (typeof ref === "string" && ref) refs.add(ref)
+    }
+  }
+
+  return [...refs]
+}
+
+function classifyToolFeedback(value: unknown): "positive" | "negative" | undefined {
+  if (!value || typeof value !== "object") return undefined
+  if (isCliError(value)) return "negative"
+  if ("ok" in value && (value as { ok?: unknown }).ok === false) return "negative"
+  if ("error" in value && typeof (value as { error?: unknown }).error === "string") return "negative"
+  if ("ok" in value && (value as { ok?: unknown }).ok === true) return "positive"
+  if ("type" in value || "hits" in value || "assetHits" in value || "sources" in value) return "positive"
+  return undefined
+}
+
+function truncateLogText(value: string, limit = 1_000): string {
+  return value.length > limit ? `${value.slice(0, limit)}…` : value
+}
+
 async function resolveRefInput(
   client: LogCapableClient,
   input: { ref?: string; query?: string },
@@ -391,7 +712,7 @@ async function resolveRefInput(
     return { ok: false, error: "Provide either 'ref' or 'query'." }
   }
 
-  const raw = await runCli(client, ["search", query, "--type", type, "--limit", "1", "--detail", "normal", "--source", "local"], meta)
+  const raw = await runCli(client, ["search", query, "--type", type, "--limit", "1", "--detail", "normal", "--source", "stash"], meta)
   const parsed = parseCliJson<SearchResponse>(raw)
   if (isCliError(parsed)) return parsed
 
@@ -440,20 +761,24 @@ function renderCommandTemplate(template: string, rawArguments: string): string {
     .replace(/\$(\d+)/g, (_m, index: string) => args[Number(index) - 1] ?? "")
 }
 
+function normalizeSearchSource(source: "local" | "stash" | "registry" | "both"): "stash" | "registry" | "both" {
+  return source === "local" ? "stash" : source
+}
+
 function createSearchArgs(input: {
   query: string
   type?: AssetType | "any"
   limit?: number
-  source?: "local" | "registry" | "both"
-  defaultSource?: "local" | "registry" | "both"
+  source?: "local" | "stash" | "registry" | "both"
+  defaultSource?: "local" | "stash" | "registry" | "both"
 }): string[] {
   const args = ["search", input.query]
   if (input.type) args.push("--type", input.type)
   if (input.limit) args.push("--limit", String(input.limit))
   if (input.source) {
-    args.push("--source", input.source)
+    args.push("--source", normalizeSearchSource(input.source))
   } else if (input.defaultSource) {
-    args.push("--source", input.defaultSource)
+    args.push("--source", normalizeSearchSource(input.defaultSource))
   }
   args.push("--detail", "normal")
   return args
@@ -479,24 +804,203 @@ type PluginClient = {
   }
 }
 
-export const AgentikitPlugin: Plugin = async ({ client }) => {
+export const AkmPlugin: Plugin = async ({ client }) => {
   await ensureLatestAkmInstalled(client as unknown as LogCapableClient)
 
+  const logClient = client as unknown as LogCapableClient
+
   return {
+    // Events cover the lifecycle boundaries that Claude Code exposes as
+    // SessionStart / Stop / PreCompact. We use them to warm the stash, capture
+    // hints for the next system transform, and flush per-session memories.
+    event: async ({ event }: { event: { type: string; properties?: unknown } }) => {
+      try {
+        const type = event?.type
+        if (!type) return
+        const sid = extractSessionIdFromEvent(event) ?? extractSessionIdFromEvent((event as { properties?: unknown }).properties)
+        if (type === "session.created" || type === "session.updated") {
+          if (!sid) return
+          if (!AKM_AUTO_HINTS) return
+          if (sessionHints.has(sid)) return
+          warmIndexInBackground()
+          const hints = runHintsForSession()
+          if (hints) sessionHints.set(sid, hints)
+        } else if (type === "session.compacted" || type === "session.idle" || type === "session.deleted") {
+          if (!sid) return
+          const captured = captureSessionMemory(sid, type)
+          if (captured) {
+            await writePluginLog(logClient, "info", "AKM session memory captured", {
+              subsystem: "memory",
+              actor: "system",
+              sessionID: sid,
+              reason: type,
+              ref: captured,
+            })
+          }
+          // Drop per-session state so a re-created session does not inherit
+          // stale hints/curation.
+          if (type === "session.deleted") {
+            sessionHints.delete(sid)
+            sessionCurated.delete(sid)
+            sessionMemoryCaptured.delete(sid)
+            sessionBuffer.delete(sid)
+          }
+        }
+      } catch {
+        // Lifecycle hooks must never throw into the TUI.
+      }
+    },
+    // Stop is the closest analogue to Claude's Stop/SubagentStop — the user or
+    // agent halted the active run. Flush the session buffer so learnings are
+    // preserved even if the session.idle event does not fire.
+    stop: async (input: unknown) => {
+      try {
+        const sid = extractSessionIdFromEvent(input)
+        if (!sid) return
+        const captured = captureSessionMemory(sid, "stop")
+        if (captured) {
+          await writePluginLog(logClient, "info", "AKM session memory captured", {
+            subsystem: "memory",
+            actor: "system",
+            sessionID: sid,
+            reason: "stop",
+            ref: captured,
+          })
+        }
+      } catch {
+        // Best-effort only.
+      }
+    },
+    // experimental.chat.system.transform is how OpenCode exposes the
+    // additionalContext channel. We append the cached hints (once per session)
+    // and the curated assets (once per turn) so the next LLM call sees them.
+    "experimental.chat.system.transform": async (
+      input: { sessionID?: string; session_id?: string } | undefined,
+      output: { system?: string[] } | undefined,
+    ) => {
+      try {
+        if (!output || !Array.isArray(output.system)) return
+        const sid = extractSessionIdFromEvent(input) ?? ""
+        const hints = sid ? sessionHints.get(sid) : undefined
+        if (hints) {
+          output.system.push(`${AKM_HINTS_PREFIX}\n\n${hints}`)
+          // Only inject hints on the first transform of the session.
+          sessionHints.delete(sid)
+        }
+        const curated = sid ? sessionCurated.get(sid) : undefined
+        if (curated) {
+          output.system.push(`${AKM_CURATED_HEADER}\n${curated}${AKM_CURATED_TAIL}`)
+          sessionCurated.delete(sid)
+        }
+      } catch {
+        // Never break the turn because of a transform failure.
+      }
+    },
+    "chat.message": async (input, output) => {
+      const text = extractText(output.parts).trim()
+      if (!text) return
+      await writePluginLog(logClient, "info", "AKM user feedback recorded", {
+        subsystem: "feedback",
+        actor: "user",
+        sessionID: input.sessionID,
+        messageID: input.messageID,
+        agent: input.agent,
+        text: truncateLogText(text),
+      })
+
+      // Compound-engineering loop: on every user message, curate the stash and
+      // stash the result so experimental.chat.system.transform can inject it.
+      if (AKM_AUTO_CURATE && input.sessionID) {
+        const curated = runCurateForPrompt(text)
+        if (curated) sessionCurated.set(input.sessionID, curated)
+      }
+
+      // Track explicit memory intents so capture-memory has something durable
+      // to flush when the session ends.
+      if (/\b(remember|memory|memories)\b/i.test(text)) {
+        addBufferEntry(input.sessionID, {
+          kind: "memory-intent",
+          note: truncateLogText(text, 500),
+        })
+      }
+    },
+    "tool.execute.after": async (input, output) => {
+      if (!input.tool.startsWith("akm_")) return
+
+      const parsed = parseToolOutput(output.output)
+      if (!parsed) return
+
+      const feedback = classifyToolFeedback(parsed)
+      if (feedback) {
+        await writePluginLog(logClient, feedback === "negative" ? "warn" : "info", "AKM system feedback recorded", {
+          subsystem: "feedback",
+          actor: "system",
+          feedback,
+          toolName: input.tool,
+          sessionID: input.sessionID,
+          callID: input.callID,
+          title: output.title,
+          error: typeof (parsed as { error?: unknown }).error === "string" ? (parsed as { error?: string }).error : undefined,
+        })
+      }
+
+      const memoryRefs = extractMemoryRefs(input.tool, input.args as Record<string, unknown>, parsed)
+      if (memoryRefs.length > 0) {
+        await writePluginLog(logClient, "info", "AKM memory usage recorded", {
+          subsystem: "memory",
+          toolName: input.tool,
+          sessionID: input.sessionID,
+          callID: input.callID,
+          refs: memoryRefs,
+        })
+      }
+
+      // Auto-feedback + session buffering: record every asset ref the tool
+      // touched so the stash ranking improves over time and so Stop/Compact
+      // has material to flush into a session summary memory.
+      const allRefs = extractToolRefs(input.tool, input.args as Record<string, unknown>, parsed)
+      if (allRefs.length > 0 && input.sessionID) {
+        for (const ref of allRefs) {
+          addBufferEntry(input.sessionID, {
+            kind: "tool-ref",
+            toolName: input.tool,
+            ref,
+            status: feedback ?? "unknown",
+          })
+        }
+      }
+
+      if (
+        AKM_AUTO_FEEDBACK
+        && feedback
+        && input.tool !== "akm_feedback"
+        && allRefs.length > 0
+      ) {
+        const note = feedback === "positive"
+          ? `opencode auto: ${input.tool} succeeded`
+          : `opencode auto: ${input.tool} failed`
+        for (const ref of allRefs) {
+          // Memories do not accept feedback in the current CLI.
+          if (ref.startsWith("memory:")) continue
+          const ok = recordFeedbackSync(ref, feedback, note)
+          if (!ok) break
+        }
+      }
+    },
     tool: {
     akm_search: tool({
-      description: "Search your local stash or the akm registry for scripts, skills, commands, agents, and knowledge. Use source='registry' or akm_registry_search for installable community kits.",
+      description: "Search your stash or the akm registry for scripts, skills, commands, agents, knowledge, and memories. Use source='registry' or akm_registry_search for installable community kits.",
       args: {
         query: tool.schema.string().describe("Case-insensitive substring search."),
         type: tool.schema
-          .enum(["skill", "command", "agent", "knowledge", "script", "any"])
+          .enum(["agent", "command", "knowledge", "memory", "script", "skill", "any"])
           .optional()
           .describe("Optional type filter. Defaults to 'any'."),
         limit: tool.schema.number().optional().describe("Maximum number of hits to return. Defaults to 20."),
         source: tool.schema
-          .enum(["local", "registry", "both"])
+          .enum(["local", "stash", "registry", "both"])
           .optional()
-          .describe("Search source. 'local' searches stash dirs, 'registry' searches npm/GitHub, 'both' searches all. Defaults to 'local'."),
+          .describe("Search source. 'stash' searches local stash directories, 'registry' searches registries, and 'both' searches all sources. 'local' remains a backward-compatible alias for 'stash'."),
       },
       async execute({ query, type, limit, source }) {
         return runCli(client as unknown as LogCapableClient, createSearchArgs({ query, type, limit, source }), { toolName: "akm_search" })
@@ -507,7 +1011,7 @@ export const AgentikitPlugin: Plugin = async ({ client }) => {
       args: {
         query: tool.schema.string().describe("Search query for installable registry kits."),
         type: tool.schema
-          .enum(["skill", "command", "agent", "knowledge", "script", "any"])
+          .enum(["agent", "command", "knowledge", "memory", "script", "skill", "any"])
           .optional()
           .describe("Optional asset type filter. Defaults to 'any'."),
         limit: tool.schema.number().optional().describe("Maximum number of registry hits to return. Defaults to 20."),
@@ -582,25 +1086,25 @@ export const AgentikitPlugin: Plugin = async ({ client }) => {
       },
     }),
     akm_list: tool({
-      description: "List all kits installed from the registry.",
+      description: "List all configured AKM sources, including local directories, managed kits, and remote providers.",
       args: {},
       async execute() {
         return runCli(client as unknown as LogCapableClient, ["list"], { toolName: "akm_list" })
       },
     }),
     akm_remove: tool({
-      description: "Remove an installed registry kit by id or ref and reindex the stash.",
+      description: "Remove a configured AKM source by id, ref, path, URL, or name and reindex the stash.",
       args: {
-        package_ref: tool.schema.string().describe("Installed kit id or ref, such as npm:@scope/kit or owner/repo."),
+        package_ref: tool.schema.string().describe("Source id, ref, path, URL, or name, such as npm:@scope/kit, owner/repo, or ~/.claude/skills."),
       },
       async execute({ package_ref }) {
         return runCli(client as unknown as LogCapableClient, ["remove", package_ref], { toolName: "akm_remove" })
       },
     }),
     akm_update: tool({
-      description: "Update one installed kit or all installed kits to the latest available version.",
+      description: "Update one managed AKM source or all managed sources to the latest available version.",
       args: {
-        package_ref: tool.schema.string().optional().describe("Installed kit id or ref to update."),
+        package_ref: tool.schema.string().optional().describe("Managed source id or ref to update."),
         all: tool.schema.boolean().optional().describe("Update all installed kits."),
         force: tool.schema.boolean().optional().describe("Force a fresh download even if the version is unchanged."),
       },
@@ -634,6 +1138,106 @@ export const AgentikitPlugin: Plugin = async ({ client }) => {
         return runCli(client as unknown as LogCapableClient, args, { toolName: "akm_clone" })
       },
     }),
+    akm_remember: tool({
+      description: "Record a memory in the default AKM stash so it can be searched and shown later.",
+      args: {
+        content: tool.schema.string().describe("Memory content to store."),
+        name: tool.schema.string().optional().describe("Optional memory name."),
+        force: tool.schema.boolean().optional().describe("Overwrite an existing memory with the same name."),
+      },
+      async execute({ content, name, force }) {
+        const args = ["remember", content]
+        if (name) args.push("--name", name)
+        if (force) args.push("--force")
+        return runCli(client as unknown as LogCapableClient, args, { toolName: "akm_remember" })
+      },
+    }),
+    akm_feedback: tool({
+      description: "Record positive or negative feedback for a stash asset so AKM can improve future ranking.",
+      args: {
+        ref: tool.schema.string().describe("Asset ref to record feedback for."),
+        sentiment: tool.schema.enum(["positive", "negative"]).describe("Whether the feedback is positive or negative."),
+        note: tool.schema.string().optional().describe("Optional note to attach to the feedback."),
+      },
+      async execute({ ref, sentiment, note }) {
+        const args = ["feedback", ref, sentiment === "positive" ? "--positive" : "--negative"]
+        if (note) args.push("--note", note)
+        return runCli(client as unknown as LogCapableClient, args, { toolName: "akm_feedback" })
+      },
+    }),
+    akm_curate: tool({
+      description: "Curate stash assets for a task or topic. Returns the top matches as a ranked list so the agent can inspect and use them.",
+      args: {
+        query: tool.schema.string().describe("Task, topic, or natural-language description of what you want to do."),
+        limit: tool.schema.number().optional().describe("Maximum number of curated matches to return. Defaults to 6."),
+        detail: tool.schema.enum(["summary", "normal", "full"]).optional().describe("Detail level for each match. Defaults to 'summary'."),
+      },
+      async execute({ query, limit, detail }) {
+        const args = [
+          "--for-agent",
+          "--format",
+          "text",
+          "--detail",
+          detail ?? "summary",
+          "-q",
+          "curate",
+          query,
+          "--limit",
+          String(limit ?? 6),
+        ]
+        return runCli(client as unknown as LogCapableClient, args, { toolName: "akm_curate" })
+      },
+    }),
+    akm_evolve: tool({
+      description: "Dispatch the AKM curator agent to review recent session activity and propose stash improvements (promote hot assets, flag cold ones, draft missing coverage).",
+      args: {
+        focus: tool.schema.string().optional().describe("Optional focus area or theme to weight the review toward."),
+        dispatch_agent: tool.schema.string().optional().describe("OpenCode agent to run the curator with. Defaults to 'general'."),
+        as_subtask: tool.schema.boolean().optional().describe("Run in a child session with parent context. Defaults to true."),
+      },
+      async execute({ focus, dispatch_agent, as_subtask }, context) {
+        const useSubtask = as_subtask ?? true
+        const targetAgent = dispatch_agent ?? "general"
+        const targetSession = await ensureTargetSessionID({
+          useSubtask,
+          context: { sessionID: context.sessionID, directory: context.directory },
+          title: "akm:curator",
+          client: client as unknown as PluginClient,
+        })
+        if (!targetSession.ok) return JSON.stringify(targetSession)
+
+        const task = focus && focus.trim()
+          ? `Review recent AKM activity with an emphasis on: ${focus.trim()}. Produce the prioritized action list described in the system prompt.`
+          : "Review recent AKM activity and produce the prioritized action list described in the system prompt."
+
+        const promptResponse = await client.session.prompt({
+          query: { directory: context.directory },
+          path: { id: targetSession.sessionID },
+          body: {
+            agent: targetAgent,
+            system: CURATOR_AGENT_PROMPT,
+            parts: [{ type: "text", text: task }],
+          },
+        })
+
+        if (promptResponse.error || !promptResponse.data) {
+          const reason = promptResponse.error ? JSON.stringify(promptResponse.error) : "empty response"
+          return JSON.stringify({
+            ok: false,
+            error: `Failed to dispatch curator: ${reason}`,
+          })
+        }
+
+        return JSON.stringify({
+          ok: true,
+          dispatchAgent: targetAgent,
+          usedSubtask: useSubtask,
+          sessionID: targetSession.sessionID,
+          focus: focus ?? null,
+          text: extractText(promptResponse.data.parts),
+        })
+      },
+    }),
     akm_agent: tool({
       description: "Dispatch a stash agent by ref into a child OpenCode session, applying the agent prompt and metadata from akm_show.",
       args: {
@@ -871,10 +1475,10 @@ export const AgentikitPlugin: Plugin = async ({ client }) => {
       },
     }),
     akm_sources: tool({
-      description: "List all resolved stash search paths and their status.",
+      description: "List all configured AKM sources. Kept as a backward-compatible alias for the older sources command.",
       args: {},
       async execute() {
-        return runCli(client as unknown as LogCapableClient, ["sources"], { toolName: "akm_sources" })
+        return runCli(client as unknown as LogCapableClient, ["list"], { toolName: "akm_sources" })
       },
     }),
     akm_upgrade: tool({

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "akm-opencode",
-  "version": "0.2.0",
+  "version": "0.4.1",
   "type": "module",
-  "description": "OpenCode plugin for Agentikit - search and show extension assets via the akm CLI.",
+  "description": "OpenCode plugin for AKM - search, show, and manage extension assets via the akm CLI, with agentic hooks that auto-load relevant stash assets, record feedback, and harvest session memories so the stash improves every session.",
   "keywords": [
     "opencode",
     "opencode-ai",
     "opencode-plugin",
     "opencode-extensions",
-    "agentikit",
+    "akm",
     "ai-agent",
     "developer-tools",
     "plugin"