akm-opencode 0.7.0 → 0.7.2

package/README.md

@@ -14,10 +14,11 @@ Add to your OpenCode config (`opencode.json`):
 
 ## Tools
 
-The plugin exposes **19 high-value tools**. Long-tail verbs (`add`, `save`, `import`, `clone`, `update`, `remove`, `list`-sources, `registry-search`, `index`-reindex, `config`, `upgrade`, ad-hoc `run`, raw `agent`) are reachable via `akm_help` plus the raw `akm` CLI through the `bash` tool.
+The plugin exposes **20 high-value tools**. Long-tail verbs (`add`, `save`, `import`, `clone`, `update`, `remove`, `list`-sources, `registry-search`, `index`-reindex, `config`, `upgrade`, ad-hoc `run`, raw `agent`) are reachable via `akm_help` plus the raw `akm` CLI through the `bash` tool.
 
 | Tool | Description |
 |------|-------------|
+| `akm_info` | Show `akm info` output together with the installed `akm-opencode` plugin version and install location |
 | `akm_search` | Search the local stash, the registry, or both. Type filter accepts `skill`, `command`, `agent`, `knowledge`, `lesson`, `memory`, `script`, `workflow`, `vault`, `wiki`, `any`; proposed hits can be included explicitly |
 | `akm_show` | Show a stash asset by its ref |
 | `akm_agent` | Dispatch a stash `agent:*` into OpenCode using the stash prompt and metadata |

package/index.ts

@@ -25,6 +25,7 @@ const AKM_RETROSPECTIVE_FEEDBACK_RE = createRetrospectiveFeedbackRegex()
 const AKM_RETROSPECTIVE_NEGATIVE_RE = createRetrospectiveNegativeRegex()
 const AKM_EXPLICIT_CORRECTION_RE = createExplicitCorrectionRegex()
 const PLUGIN_VERSION = readPackageVersion()
+const PLUGIN_INSTALL_LOCATION = moduleDir
 
 // Per-session state that drives the compound-engineering loop.
 // These maps are keyed by OpenCode sessionID.
@@ -52,6 +53,7 @@ const sessionSuccessfulAssetTouchCount = new Map<string, number>()
 const pendingProposalSummaryCache = new Map<string, { count: number; expiresAt: number; unsupported?: boolean }>()
 const retrospectiveState = new Map<string, { recentRefs: string[]; lastNegativeSignalAt?: number }>()
 let cachedAkmStashDir: string | undefined
+let agentSetupPromise: Promise<boolean> | null = null
 
 // Asset-ref grammar matching the stash skill: [origin//]type:name.
 // We validate normalized tokens individually instead of running a global regex
@@ -217,6 +219,16 @@ function formatCliError(error: unknown): string {
   return error instanceof Error ? error.message : String(error)
 }
 
+function needsAgentSetup(message: string): boolean {
+  return /(agent commands are disabled|agent not configured|no [`'"]?agent[`'"]? block in config\.json)/i.test(message)
+}
+
+function addAgentSetupGuidance(message: string): string {
+  if (!needsAgentSetup(message)) return message
+  if (/\bakm_setup\b|\bakm setup\b/i.test(message)) return message
+  return `${message}. Run akm_setup to detect an installed agent CLI and persist agent.default. If none is installed yet, install one of: opencode, claude, codex, gemini, aider.`
+}
+
 function toLogString(value: unknown): string | undefined {
   if (typeof value === "string") return value
   if (value instanceof Buffer) return value.toString("utf8")
@@ -245,6 +257,79 @@ async function writePluginLog(client: LogCapableClient, level: LogLevel, message
   }
 }
 
+async function runAgentSetup(client: LogCapableClient, meta: { directory?: string; sessionID?: string; trigger: string; force?: boolean }): Promise<boolean> {
+  const command = resolveAkmCommand()
+  if (typeof command !== "string") {
+    await writePluginLog(client, "warn", "AKM agent setup skipped", {
+      subsystem: "akm",
+      trigger: meta.trigger,
+      sessionID: meta.sessionID,
+      directory: meta.directory,
+      error: command.error,
+    })
+    return false
+  }
+
+  const args = ["setup"]
+  if (meta.force) args.push("--force")
+  args.push("--format", "json")
+
+  try {
+    const stdout = execFileSync(command, args, {
+      encoding: "utf8",
+      timeout: 30_000,
+    })
+    const parsed = safeJsonParse<{ ok?: boolean; error?: string }>(stdout)
+    if (parsed?.ok === false) {
+      await writePluginLog(client, "warn", "AKM agent setup reported an error", {
+        subsystem: "akm",
+        trigger: meta.trigger,
+        sessionID: meta.sessionID,
+        directory: meta.directory,
+        command,
+        args,
+        stdout,
+        error: parsed.error ?? "Unknown akm setup error",
+      })
+      return false
+    }
+    await writePluginLog(client, "info", "AKM agent setup completed", {
+      subsystem: "akm",
+      trigger: meta.trigger,
+      sessionID: meta.sessionID,
+      directory: meta.directory,
+      command,
+      args,
+      stdout,
+    })
+    return true
+  } catch (error: unknown) {
+    const message = addAgentSetupGuidance(formatCliError(error))
+    await writePluginLog(client, "warn", "AKM agent setup failed", {
+      subsystem: "akm",
+      trigger: meta.trigger,
+      sessionID: meta.sessionID,
+      directory: meta.directory,
+      command,
+      args,
+      error: message,
+      stdout: toLogString((error as { stdout?: unknown }).stdout) ?? "",
+      stderr: toLogString((error as { stderr?: unknown }).stderr) ?? message,
+    })
+    return false
+  }
+}
+
+async function ensureAgentSetup(client: LogCapableClient, meta: { directory?: string; sessionID?: string; trigger: string; force?: boolean }): Promise<boolean> {
+  if (agentSetupPromise) return agentSetupPromise
+  const promise = runAgentSetup(client, meta)
+  const trackedPromise = promise.finally(() => {
+    if (agentSetupPromise === trackedPromise) agentSetupPromise = null
+  })
+  agentSetupPromise = trackedPromise
+  return trackedPromise
+}
+
 function nowIso(): string {
   return new Date().toISOString()
 }
@@ -677,6 +762,21 @@ function queueFeedback(
         stdio: "ignore",
       },
     )
+    child.on("exit", (code, signal) => {
+      if ((typeof code === "number" && code !== 0) || signal) {
+        void writePluginLog(client, "warn", "AKM auto-feedback failed", {
+          subsystem: "feedback",
+          toolName: meta.toolName,
+          sessionID: meta.sessionID,
+          directory: meta.directory,
+          ref,
+          sentiment,
+          error: signal
+            ? `akm feedback exited via signal ${signal}`
+            : `akm feedback exited with code ${code}`,
+        })
+      }
+    })
     child.on("error", (error) => {
       void writePluginLog(client, "warn", "AKM auto-feedback failed", {
         subsystem: "feedback",
@@ -1313,11 +1413,7 @@ async function runCli(client: LogCapableClient, args: string[], meta: CliLogMeta
   const fullArgs = args.includes("--format") ? [...args] : [...args, "--format", "json"]
   const proposalId = args[0] === "proposal" && typeof args[2] === "string" ? args[2] : null
 
-  try {
-    const stdout = execFileSync(command, fullArgs, {
-      encoding: "utf8",
-      timeout: 60_000,
-    })
+  const recordSuccess = async (stdout: string): Promise<string> => {
     await writePluginLog(client, "info", "AKM command completed", {
       subsystem: "akm",
       toolName: meta.toolName,
@@ -1383,8 +1479,45 @@ async function runCli(client: LogCapableClient, args: string[], meta: CliLogMeta
       })
     }
     return stdout
+  }
+
+  try {
+    const stdout = execFileSync(command, fullArgs, {
+      encoding: "utf8",
+      timeout: 60_000,
+    })
+    return recordSuccess(stdout)
   } catch (error: unknown) {
-    const message = formatCliError(error)
+    let message = formatCliError(error)
+    if (["akm_reflect", "akm_propose"].includes(meta.toolName) && needsAgentSetup(message)) {
+      const setupOk = await ensureAgentSetup(client, {
+        directory: meta.directory,
+        sessionID: meta.sessionID,
+        trigger: `${meta.toolName}:retry`,
+        force: true,
+      })
+      if (setupOk) {
+        try {
+          const stdout = execFileSync(command, fullArgs, {
+            encoding: "utf8",
+            timeout: 60_000,
+          })
+          await writePluginLog(client, "info", "AKM command recovered after setup", {
+            subsystem: "akm",
+            toolName: meta.toolName,
+            sessionID: meta.sessionID,
+            directory: meta.directory,
+            command,
+            args: fullArgs,
+          })
+          return recordSuccess(stdout)
+        } catch (retryError: unknown) {
+          error = retryError
+          message = formatCliError(retryError)
+        }
+      }
+    }
+    message = addAgentSetupGuidance(message)
     await writePluginLog(client, "error", "AKM command failed", {
       subsystem: "akm",
       toolName: meta.toolName,
@@ -1536,6 +1669,17 @@ function parseCliJson<T>(raw: string): T | CliError {
   }
 }
 
+function formatAkmInfoResponse(raw: string): string {
+  const parsed = parseCliJson<Record<string, unknown>>(raw)
+  if (isCliError(parsed)) return JSON.stringify(parsed)
+  return JSON.stringify({
+    ok: true,
+    pluginVersion: PLUGIN_VERSION,
+    pluginInstallLocation: PLUGIN_INSTALL_LOCATION,
+    akmInfo: parsed,
+  })
+}
+
 function blockedToolResponse(args: Record<string, unknown>): string | null {
   return typeof args.__akmBlocked === "string"
     ? JSON.stringify({ ok: false, error: args.__akmBlocked })
@@ -1968,6 +2112,11 @@ export const AkmPlugin: Plugin = async ({ client, worktree, directory }) => {
           if (!sid) return
           if (!sessionContextEpoch.has(sid)) sessionContextEpoch.set(sid, 0)
           if (type === "session.created") {
+            await ensureAgentSetup(logClient, {
+              directory,
+              sessionID: sid,
+              trigger: "session.created",
+            })
             warmIndexInBackground()
             if (AKM_AUTO_CURATE && !sessionCurated.has(sid)) {
               const curated = runCurateForSession(sid)
@@ -2043,24 +2192,6 @@ export const AkmPlugin: Plugin = async ({ client, worktree, directory }) => {
         // Best-effort only.
       }
     },
-    "experimental.session.compacting": async (input, output) => {
-      try {
-        const sid = input.sessionID
-        if (!sid) return
-        if (!Array.isArray(output.context)) return
-        markContextEpochDirty(sid)
-        const blocks = [
-          sessionHints.get(sid) ? `${AKM_HINTS_PREFIX}\n\n${sessionHints.get(sid)}` : "",
-          sessionCurated.get(sid) ? `${AKM_CURATED_HEADER}\n${sessionCurated.get(sid)}${AKM_CURATED_TAIL}` : "",
-          sessionWorkflow.get(sid) ? formatWorkflowContext(sessionWorkflow.get(sid)!) : "",
-          (await getPendingProposalCount(logClient, sid)).count > 0 && !(await getPendingProposalCount(logClient, sid)).unsupported ? formatPendingProposalContext((await getPendingProposalCount(logClient, sid)).count) : "",
-          sessionCuratorReport.get(sid) ? formatCuratorReportContext(sessionCuratorReport.get(sid)!) : "",
-        ]
-        output.context.push(...applyContextBudget(blocks))
-      } catch {
-        // Never break compaction because of plugin context.
-      }
-    },
     // 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.
@@ -2176,142 +2307,172 @@ export const AkmPlugin: Plugin = async ({ client, worktree, directory }) => {
       }
     },
     "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),
-      })
+      try {
+        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, input.sessionID)
-        if (curated) {
-          sessionCurated.set(input.sessionID, curated)
-          bumpCuratedVersion(input.sessionID)
+        // 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, input.sessionID)
+          if (curated) {
+            sessionCurated.set(input.sessionID, curated)
+            bumpCuratedVersion(input.sessionID)
+          }
         }
-      }
 
-      // 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),
-        })
-      }
+        // 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),
+          })
+        }
 
-      if (input.sessionID && AKM_AUTO_FEEDBACK && AKM_RETROSPECTIVE_FEEDBACK_RE.test(text)) {
-        const recentRefs = (sessionBuffer.get(input.sessionID) ?? [])
-          .filter((entry) => entry.kind === "tool-ref" && !!entry.ref)
-          .map((entry) => entry.ref!)
-          .filter((ref, index, refs) => !ref.startsWith("memory:") && !ref.startsWith("vault:") && refs.indexOf(ref) === index)
-          .slice(-3)
-        const dedupe = new Set<string>()
-        for (const ref of recentRefs) {
-          queueFeedback(logClient, ref, "positive", "opencode retrospective: user confirmed it worked", {
-            toolName: "chat.message",
-            sessionID: input.sessionID,
-          }, dedupe)
+        if (input.sessionID && AKM_AUTO_FEEDBACK && AKM_RETROSPECTIVE_FEEDBACK_RE.test(text)) {
+          const recentRefs = (sessionBuffer.get(input.sessionID) ?? [])
+            .filter((entry) => entry.kind === "tool-ref" && !!entry.ref)
+            .map((entry) => entry.ref!)
+            .filter((ref, index, refs) => !ref.startsWith("memory:") && !ref.startsWith("vault:") && refs.indexOf(ref) === index)
+            .slice(-3)
+          const dedupe = new Set<string>()
+          for (const ref of recentRefs) {
+            queueFeedback(logClient, ref, "positive", "opencode retrospective: user confirmed it worked", {
+              toolName: "chat.message",
+              sessionID: input.sessionID,
+            }, dedupe)
+          }
         }
+        await recordRetrospectiveFeedback(logClient, input.sessionID, text)
+      } catch (error: unknown) {
+        await writePluginLog(logClient, "error", "AKM chat.message hook failed", {
+          subsystem: "hook",
+          hook: "chat.message",
+          sessionID: input?.sessionID,
+          messageID: input?.messageID,
+          agent: input?.agent,
+          error: formatCliError(error),
+        })
       }
-      await recordRetrospectiveFeedback(logClient, input.sessionID, text)
     },
     "tool.execute.after": async (input, output) => {
-      if (!input.tool.startsWith("akm_")) return
+      try {
+        if (!input.tool.startsWith("akm_")) return
 
-      const parsed = parseToolOutput(output.output)
-      if (!parsed) 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 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,
-        })
-      }
+        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.
+        // 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 refResult = extractToolRefs(input.tool, input.args as Record<string, unknown>, parsed)
         noteRecentRefs(input.sessionID, refResult.refs)
         if (refResult.refs.length > 0 && input.sessionID) {
-        for (const ref of refResult.refs) {
-          addBufferEntry(input.sessionID, {
-            kind: "tool-ref",
-            toolName: input.tool,
-            ref,
-            status: feedback ?? "unknown",
-          })
-        }
-        if (feedback === "positive") {
-          sessionSuccessfulAssetTouchCount.set(
-            input.sessionID,
-            (sessionSuccessfulAssetTouchCount.get(input.sessionID) ?? 0) + 1,
-          )
-          const checkpointRef = maybeCheckpointSessionMemory(input.sessionID)
-          if (checkpointRef) {
-            await writePluginLog(logClient, "info", "AKM checkpoint memory captured", {
-              subsystem: "memory",
-              actor: "system",
-              sessionID: input.sessionID,
-              reason: "checkpoint",
-              ref: checkpointRef,
+          for (const ref of refResult.refs) {
+            addBufferEntry(input.sessionID, {
+              kind: "tool-ref",
+              toolName: input.tool,
+              ref,
+              status: feedback ?? "unknown",
             })
           }
+          if (feedback === "positive") {
+            sessionSuccessfulAssetTouchCount.set(
+              input.sessionID,
+              (sessionSuccessfulAssetTouchCount.get(input.sessionID) ?? 0) + 1,
+            )
+            const checkpointRef = maybeCheckpointSessionMemory(input.sessionID)
+            if (checkpointRef) {
+              await writePluginLog(logClient, "info", "AKM checkpoint memory captured", {
+                subsystem: "memory",
+                actor: "system",
+                sessionID: input.sessionID,
+                reason: "checkpoint",
+                ref: checkpointRef,
+              })
+            }
+          }
         }
-      }
 
-      if (
-        AKM_AUTO_FEEDBACK
-        && feedback
-        && input.tool !== "akm_feedback"
-        && refResult.refs.length > 0
-      ) {
-        const dedupe = new Set<string>()
-        const feedbackRefs = feedback === "positive"
-          ? refResult.refs
-          : refResult.refs.filter((ref) => !refResult.positiveOnlyRefs.includes(ref))
-        const note = feedback === "positive"
-          ? `opencode auto: ${input.tool} succeeded`
-          : `opencode auto: ${input.tool} failed`
-        for (const ref of feedbackRefs) {
-          // Memories and vault refs are not first-class feedback targets —
-          // memories do not accept feedback, and vault values never surface in
-          // JSON so automatic usage signals would be misleading.
-          if (ref.startsWith("memory:") || ref.startsWith("vault:")) continue
-          const ok = queueFeedback(logClient, ref, feedback, note, {
-            toolName: input.tool,
-            sessionID: input.sessionID,
-          }, dedupe)
-          if (!ok) break
+        if (
+          AKM_AUTO_FEEDBACK
+          && feedback
+          && input.tool !== "akm_feedback"
+          && refResult.refs.length > 0
+        ) {
+          const dedupe = new Set<string>()
+          const feedbackRefs = feedback === "positive"
+            ? refResult.refs
+            : refResult.refs.filter((ref) => !refResult.positiveOnlyRefs.includes(ref))
+          const note = feedback === "positive"
+            ? `opencode auto: ${input.tool} succeeded`
+            : `opencode auto: ${input.tool} failed`
+          for (const ref of feedbackRefs) {
+            // Memories and vault refs are not first-class feedback targets —
+            // memories do not accept feedback, and vault values never surface in
+            // JSON so automatic usage signals would be misleading.
+            if (ref.startsWith("memory:") || ref.startsWith("vault:")) continue
+            const ok = queueFeedback(logClient, ref, feedback, note, {
+              toolName: input.tool,
+              sessionID: input.sessionID,
+            }, dedupe)
+            if (!ok) break
+          }
         }
+      } catch (error: unknown) {
+        await writePluginLog(logClient, "error", "AKM tool.execute.after hook failed", {
+          subsystem: "hook",
+          hook: "tool.execute.after",
+          toolName: input?.tool,
+          sessionID: input?.sessionID,
+          callID: input?.callID,
+          error: formatCliError(error),
+        })
       }
     },
     tool: {
+    akm_info: tool({
+      description: "Show `akm info` output plus the installed akm-opencode plugin version and install location.",
+      args: {},
+      async execute() {
+        const raw = await runCli(client as unknown as LogCapableClient, ["info"], { toolName: "akm_info" })
+        return formatAkmInfoResponse(raw)
+      },
+    }),
     akm_search: tool({
       description: "Search your stash or the akm registry for scripts, skills, commands, agents, knowledge, memories, workflows, vaults, and wikis. Use source='registry' for installable community kits.",
       args: {
@@ -2480,16 +2641,27 @@ export const AkmPlugin: Plugin = async ({ client, worktree, directory }) => {
       description: "Read compact text summaries of the parent session's messages so a dispatched AKM subagent can inherit upstream context.",
       args: {},
       async execute(_input, context) {
-        const parent = await getParentSessionID(sdkClient, context.sessionID, context.directory)
-        if (!parent.ok) return JSON.stringify(parent)
-        const messages = await sdkClient.session.messages({
-          path: { id: parent.parentID },
-          query: { directory: context.directory },
-        })
-        if (messages.error || !messages.data) {
+        try {
+          const parent = await getParentSessionID(sdkClient, context.sessionID, context.directory)
+          if (!parent.ok) return JSON.stringify(parent)
+          const messages = await sdkClient.session.messages({
+            path: { id: parent.parentID },
+            query: { directory: context.directory },
+          })
+          if (messages.error || !messages.data) {
+            return JSON.stringify({ ok: false, error: "Failed to read parent session messages." })
+          }
+          return JSON.stringify(summarizeSessionMessages(parent.parentID, messages.data))
+        } catch (error: unknown) {
+          await writePluginLog(logClient, "error", "AKM parent session read failed", {
+            subsystem: "session",
+            toolName: "akm_parent_messages",
+            sessionID: context.sessionID,
+            directory: context.directory,
+            error: formatCliError(error),
+          })
           return JSON.stringify({ ok: false, error: "Failed to read parent session messages." })
         }
-        return JSON.stringify(summarizeSessionMessages(parent.parentID, messages.data))
       },
     }),
     akm_session_messages: tool({
@@ -2498,23 +2670,35 @@ export const AkmPlugin: Plugin = async ({ client, worktree, directory }) => {
         session_id: tool.schema.string().describe("OpenCode session ID to inspect."),
       },
       async execute({ session_id }, context) {
-        const parent = await getParentSessionID(sdkClient, context.sessionID, context.directory)
-        const allowedSessionIDs = new Set<string>([context.sessionID])
-        if (parent.ok) allowedSessionIDs.add(parent.parentID)
-        if (context.agent !== "akm-curator" && !allowedSessionIDs.has(session_id)) {
-          return JSON.stringify({
-            ok: false,
-            error: "akm_session_messages only allows arbitrary session IDs for the akm-curator agent. Use akm_parent_messages for parent context.",
+        try {
+          const parent = await getParentSessionID(sdkClient, context.sessionID, context.directory)
+          const allowedSessionIDs = new Set<string>([context.sessionID])
+          if (parent.ok) allowedSessionIDs.add(parent.parentID)
+          if (context.agent !== "akm-curator" && !allowedSessionIDs.has(session_id)) {
+            return JSON.stringify({
+              ok: false,
+              error: "akm_session_messages only allows arbitrary session IDs for the akm-curator agent. Use akm_parent_messages for parent context.",
+            })
+          }
+          const messages = await sdkClient.session.messages({
+            path: { id: session_id },
+            query: { directory: context.directory },
+          })
+          if (messages.error || !messages.data) {
+            return JSON.stringify({ ok: false, error: `Failed to read messages for session '${session_id}'.` })
+          }
+          return JSON.stringify(summarizeSessionMessages(session_id, messages.data))
+        } catch (error: unknown) {
+          await writePluginLog(logClient, "error", "AKM session messages read failed", {
+            subsystem: "session",
+            toolName: "akm_session_messages",
+            sessionID: context.sessionID,
+            directory: context.directory,
+            targetSessionID: session_id,
+            error: formatCliError(error),
           })
-        }
-        const messages = await sdkClient.session.messages({
-          path: { id: session_id },
-          query: { directory: context.directory },
-        })
-        if (messages.error || !messages.data) {
           return JSON.stringify({ ok: false, error: `Failed to read messages for session '${session_id}'.` })
         }
-        return JSON.stringify(summarizeSessionMessages(session_id, messages.data))
       },
     }),
     akm_agent: tool({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akm-opencode",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "type": "module",
   "description": "OpenCode plugin for AKM v0.7.0 - search, show, and manage extension assets via the akm CLI, including vaults, wikis, workflows, the proposal queue, lesson assets, and reflect/propose/distill commands, with agentic hooks that auto-load relevant stash assets, record feedback, and harvest session memories so the stash improves every session.",
   "keywords": [