akm-opencode 0.9.20202610010009 → 0.9.21202610012143

package/README.md

@@ -1,6 +1,6 @@
 # akm-opencode
 
-OpenCode plugin for [AKM](https://github.com/itlackey/akm) `0.9.20`. It exposes exactly five public tools and uses lifecycle hooks to bring relevant AKM context into a session. The dependency is exact-pinned because the plugin calls AKM's in-process `dist/` APIs.
+OpenCode plugin for [AKM](https://github.com/itlackey/akm) `0.9.21`. It exposes exactly five public tools and uses lifecycle hooks to bring relevant AKM context into a session. The dependency is exact-pinned because the plugin calls AKM's in-process `dist/` APIs.
 
 ## Installation
 
@@ -56,7 +56,7 @@ The plugin subscribes to OpenCode lifecycle events. Hook failures are logged thr
 
 The session observation buffer that retrospective feedback reads from survives every non-terminal event: it is bounded by `AKM_SESSION_BUFFER_MAX_ENTRIES` and dropped only on `session.deleted`. Discarding it at `session.idle` would empty it between turns, so "thanks, that worked" would credit nothing in exactly the sessions that used the most assets.
 
-Automatic feedback skips references that AKM reports as ineligible, and no `akm_*` tool call submits feedback on its own. A *successful* `akm_show` / `akm_search` / `akm_curate` only inspected a concept, which is not evidence that it helped, so on OpenCode the positive signal comes from a retrospective confirmation instead. A *failed* call (an error result, a timeout, an ambiguous ref) is not feedback on the asset either, and is only logged. Same rules as the Claude plugin, which applies them to the `akm` subcommand of a Bash invocation.
+Automatic feedback skips references that AKM reports as ineligible, and no `akm_*` tool call submits feedback on its own. A *successful* `akm_show` / `akm_search` / `akm_curate` only inspected a concept, which is not evidence that it helped, so on OpenCode the positive signal comes from a retrospective confirmation instead. A *failed* call (an error result, a timeout, an ambiguous ref) is not feedback on the asset either, and is only logged: its ref is not remembered as used, so a later "thanks, that worked" does not credit it and a later correction does not blame it. Same rules as the Claude plugin, which applies them to the `akm` subcommand of a Bash invocation.
 
 ### Automatic learning proposals
 

package/dist/index.js

@@ -119,6 +119,7 @@ function shouldSubmitAutomaticFeedback(signal) {
 
 // ../claude/shared/memory-events.ts
 import { appendFileSync, existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
 import path from "path";
 
 // ../claude/shared/redaction.ts
@@ -376,7 +377,7 @@ function rotateIfOversized(filePath) {
 
 // ../claude/shared/memory-events.ts
 function getHarnessStateDir(harness) {
-  const root = process.env.XDG_STATE_HOME ?? path.join(process.env.HOME ?? ".", ".local", "state");
+  const root = process.env.XDG_STATE_HOME ?? path.join(homedir(), ".local", "state");
   return path.join(root, harness === "claude-code" ? "akm-claude" : "akm-opencode");
 }
 function getEventLogPath(harness) {
@@ -1008,8 +1009,45 @@ function isFile(file) {
     return false;
   }
 }
+var SCRIPT_EXTENSIONS = new Set([
+  ".sh",
+  ".ts",
+  ".js",
+  ".ps1",
+  ".cmd",
+  ".bat",
+  ".py",
+  ".rb",
+  ".go",
+  ".pl",
+  ".php",
+  ".lua",
+  ".r",
+  ".swift",
+  ".kt",
+  ".kts"
+]);
+function markdownFile(directPath) {
+  return isFile(`${directPath}.md`) || directPath.endsWith(".md") && isFile(directPath);
+}
+function isAsset(type, directPath) {
+  if (type === "skills")
+    return isFile(path3.join(directPath, "SKILL.md"));
+  if (type === "scripts")
+    return SCRIPT_EXTENSIONS.has(path3.extname(directPath).toLowerCase()) && isFile(directPath);
+  if (type === "secrets")
+    return !/\.(lock|sensitive)$/.test(directPath) && isFile(directPath);
+  if (type === "tasks")
+    return isFile(`${directPath}.yml`);
+  if (type === "env") {
+    return isFile(`${directPath}.env`) || path3.basename(directPath) === "default" && isFile(path3.join(path3.dirname(directPath), ".env"));
+  }
+  return markdownFile(directPath) || type === "workflows" && isFile(`${directPath}.yml`);
+}
+var OUTSIDE_THEIR_DIRECTORY = new Set(["scripts", "agents", "commands", "facts", "instructions", "knowledge", "lessons", "memories", "sessions"]);
 function conceptExistsInAnyBundle(conceptId, bundleRoots) {
   const type = conceptId.split("/", 1)[0];
+  const rest = conceptId.slice(type.length + 1);
   for (const root of bundleRoots) {
     if (!root)
       continue;
@@ -1017,16 +1055,10 @@ function conceptExistsInAnyBundle(conceptId, bundleRoots) {
     const directPath = path3.resolve(resolvedRoot, conceptId);
     if (directPath !== resolvedRoot && !directPath.startsWith(`${resolvedRoot}${path3.sep}`))
       continue;
-    if (type === "skills") {
-      if (isFile(path3.join(directPath, "SKILL.md")))
-        return true;
-    } else if (type === "scripts" || type === "secrets") {
-      if (isFile(directPath))
-        return true;
-    } else {
-      if (isFile(`${directPath}.md`) || directPath.endsWith(".md") && isFile(directPath))
-        return true;
-      if (type === "memories" && isFile(`${directPath}.derived.md`))
+    if (isAsset(type, directPath))
+      return true;
+    if (OUTSIDE_THEIR_DIRECTORY.has(type) && rest.includes("/") && !rest.startsWith(`${type}/`)) {
+      if (isAsset(type, path3.resolve(resolvedRoot, rest)))
         return true;
     }
   }
@@ -1050,14 +1082,39 @@ function validateRefCandidates(candidates, bundleRoots) {
 // ../claude/shared/recall-policy.ts
 var STASH_BOILERPLATE = "This is an **AKM stash** \u2014 a structured knowledge repository that stores reusable";
 var COMPACTION_CONTINUATION = "This session is being continued from a previous conversation";
+var TAG = /<(\/?)([A-Za-z][\w:.-]*)(?:\s[^<>]*)?>/g;
+function leadingBlockEnd(text) {
+  const tags = new RegExp(TAG);
+  let name;
+  let depth = 0;
+  for (let tag = tags.exec(text);tag; tag = tags.exec(text)) {
+    if (name === undefined) {
+      if (tag.index !== 0 || tag[1])
+        return -1;
+      name = tag[2];
+    } else if (tag[2] !== name)
+      continue;
+    depth += tag[1] ? -1 : 1;
+    if (depth === 0)
+      return tag.index + tag[0].length;
+  }
+  return -1;
+}
+function stripLeadingEnvelopes(text) {
+  let rest = text.trimStart();
+  for (let end = leadingBlockEnd(rest);end > 0; end = leadingBlockEnd(rest))
+    rest = rest.slice(end).trimStart();
+  return rest;
+}
 function isNonTaskPrompt(text) {
-  const stripped = text.trimStart();
-  if (stripped === STASH_BOILERPLATE || stripped.startsWith(COMPACTION_CONTINUATION))
+  const typed = stripLeadingEnvelopes(text);
+  if (typed === STASH_BOILERPLATE || typed.startsWith(COMPACTION_CONTINUATION))
     return true;
-  return stripped.startsWith("<") && stripped.includes("</");
+  return typed === "" ? text.trim() !== "" : typed.startsWith("<") && typed.includes("</");
 }
 function shouldRecall(prompt, options) {
-  const text = prompt.trim();
+  const trimmed = prompt.trim();
+  const text = stripLeadingEnvelopes(trimmed) || trimmed;
   const lower = text.toLowerCase();
   const scopeHints = [];
   if (!text)
@@ -1219,7 +1276,7 @@ var retrospectiveState = new Map;
 var cachedAkmBundleDir;
 var PROPOSED_QUALITY_WARNING = "Do not treat proposed assets as curated until accepted.";
 var AKM_WORKFLOW_INSTRUCTION = [
-  "# AKM workflow (v0.9.20)",
+  "# AKM workflow (v0.9.21)",
   "",
   "Use AKM as a reusable knowledge and workflow bundle.",
   "",
@@ -2373,12 +2430,12 @@ var AKM_HINTS_PREFIX = [
   '- **`akm_search` (known name)** \u2014 use ONLY when you already know an asset exists (e.g. after `akm_show` returned "not found") and need to locate its exact ref. Do not use as a discovery tool.',
   "- **`akm_show <bundle>//meta`** \u2014 when working in or with an unfamiliar bundle, read its optional `.meta/` orientation (purpose, key assets, conventions, maintainer) before diving in. `akm_show meta` reads your working bundle's `.meta/index.md`; `akm_show meta:<name>` reads other `.meta/` docs (e.g. `meta:about`). These docs are direct-read and never appear in `akm_search`.",
   "",
-  "Record `akm_feedback <ref> positive|negative` whenever an asset's content materially helps, or proves wrong, stale or unhelpful (a failed akm call is not feedback on the asset), and use `akm_remember` to persist durable learnings so future sessions inherit them.",
+  "When an asset's content is wrong, stale or incomplete, call `akm_feedback <ref> negative` with a note saying <what is wrong and what should change>: negative feedback is what triggers a review and fix of the asset, so make the note specific. Call it with `positive` when an asset materially helped (it only improves ranking). A failed akm call is not feedback on the asset. Use `akm_remember` to persist durable learnings so future sessions inherit them.",
   "",
   AKM_WORKFLOW_INSTRUCTION
 ].join(`
 `);
-var 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.";
+var AKM_CURATED_TAIL = "\n\nTip: call `akm_show <ref>` to fetch full content. If an asset is wrong, stale or incomplete, call `akm_feedback <ref> negative` with a note saying <what is wrong and what should change>: that queues it for review and a fix. Use `positive` when it helped.";
 var AKM_CONTEXT_TRUNCATED_MARKER = `
 
 [truncated for context]`;
@@ -3276,6 +3333,7 @@ ${hint}` : hint;
         const candidateRefs = [...new Set([...allArgRefs, ...allOutputRefs])];
         const parsedForRefs = isAkmTool ? parseToolOutput(output.output) : null;
         const allRefs = isAkmTool && parsedForRefs ? extractToolRefs(input.tool, input.args, parsedForRefs) : validateRefCandidates(candidateRefs, [await getAkmBundleDir(logClient) ?? ""]);
+        const failedCall = classifyToolFeedback(parsedForRefs) === "negative";
         if (allRefs.length > 0) {
           writeStructuredEvent({
             event: "tool_ref_observed",
@@ -3285,13 +3343,15 @@ ${hint}` : hint;
             refs: allRefs,
             outcome: { status: "ok" }
           });
-          for (const ref of allRefs) {
-            addBufferEntry(input.sessionID, {
-              kind: "tool-ref",
-              toolName: input.tool,
-              ref,
-              status: "unknown"
-            });
+          if (!failedCall) {
+            for (const ref of allRefs) {
+              addBufferEntry(input.sessionID, {
+                kind: "tool-ref",
+                toolName: input.tool,
+                ref,
+                status: "unknown"
+              });
+            }
           }
         }
         if (input.tool === "read") {
@@ -3328,7 +3388,8 @@ ${hint}` : hint;
         if ((input.tool === "akm_show" || input.tool === "akm_curate") && feedback !== "negative") {
           noteShownRefs(input.sessionID, toolRefs);
         }
-        noteRecentRefs(input.sessionID, toolRefs);
+        if (!failedCall)
+          noteRecentRefs(input.sessionID, toolRefs);
         writeStructuredEvent({
           event: "tool_observation",
           sessionId: input.sessionID,
@@ -3337,7 +3398,7 @@ ${hint}` : hint;
           refs: toolRefs,
           outcome: { status: feedback === "negative" ? "failed" : "ok" }
         });
-        if (toolRefs.length > 0 && input.sessionID) {
+        if (toolRefs.length > 0 && input.sessionID && !failedCall) {
           for (const ref of toolRefs) {
             addBufferEntry(input.sessionID, {
               kind: "tool-ref",
@@ -3416,11 +3477,11 @@ ${hint}` : hint;
         }
       }),
       akm_feedback: tool({
-        description: "Record positive or negative feedback for a bundle asset so AKM can improve future ranking. Call it after akm_show whenever the asset's content materially helped, or proved wrong, stale or unhelpful. A failed akm call is not feedback on the asset.",
+        description: "Record feedback for a bundle asset. Negative feedback with a note queues the asset for review: the next improve run proposes a fix based on the note, so say what is wrong and what should change. Positive feedback raises the asset's ranking and never triggers a rewrite. Call it after akm_show when the asset's content materially helped, or proved wrong, stale or incomplete. A failed akm call is not feedback on the asset.",
         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.")
+          note: tool.schema.string().optional().describe("What is wrong and what should change. Required for negative feedback; it guides the fix.")
         },
         async execute({ ref, sentiment, note }, context) {
           const args = ["feedback", ref, sentiment === "positive" ? "--positive" : "--negative"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akm-opencode",
-  "version": "0.9.20202610010009",
+  "version": "0.9.21202610012143",
   "type": "module",
   "description": "OpenCode plugin for AKM with discovery tools, feedback, memory, and automatic learning proposals from corrections and recurring workflows.",
   "keywords": [
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@opencode-ai/plugin": "^1.18.14",
-    "akm-cli": "0.9.20"
+    "akm-cli": "0.9.21"
   },
   "devDependencies": {
     "@types/node": "^26.1.1",