fix(skill-memory): address council should-level findings

- budgetFill now counts per-note XML framing (~20 tokens) so the rendered
  <skill-memory> block stays within max_tokens instead of ~13% overshoot (rev-1).
- clamp effective pinned budget to min(max_pinned_tokens, max_tokens) so the
  default 4000>1500 can't imply pinned gets more room than the whole block (rev-2).
- ctx_skill_recall: derive tier via dirname(resolvedPath) instead of a fragile
  .replace('/SKILL.md','') (rev-2).
Updated the budget-truncation test for the framing-inclusive math.

Author: Tehan

packages/plugin/src/features/magic-context/skill-memory/recall.test.ts

@@ -53,12 +53,13 @@ describe("flatRecall", () => {
                     createdAt: now - i * 1000,
                 });
             }
-            // Token-budget truncation test (arithmetic verified):
-            // delta = "note N — " (9 chars) + 40 "x"s = 49 chars → Math.ceil(49/4) = 13 tokens each.
-            // maxTokens: 30 → first note fits (13 ≤ 30), second note fits (13+13=26 ≤ 30),
-            // third note would exceed (26+13=39 > 30) → exactly 2 notes fit.
+            // Token-budget truncation test (arithmetic verified, framing-inclusive):
+            // delta = "note N — " (9 chars) + 40 "x"s = 49 chars → Math.ceil(49/4) = 13 tokens,
+            // plus NOTE_FRAMING_TOKENS (20) for the <note>…</note> wrapper = 33 tokens each.
+            // maxTokens: 70 → 1st fits (33 ≤ 70), 2nd fits (33+33=66 ≤ 70),
+            // 3rd would exceed (66+33=99 > 70) → exactly 2 notes fit.
             const notes = flatRecall(db, "tdd", "global", "git:abc", {
-                maxTokens: 30, // 2 notes × 13 tokens = 26 ≤ 30; 3rd note would push to 39 > 30
+                maxTokens: 70, // 2 notes × 33 tokens = 66 ≤ 70; 3rd would push to 99 > 70
                 maxPinnedTokens: 4000,
             });
             expect(notes.length).toBe(2);

packages/plugin/src/features/magic-context/skill-memory/recall.ts

@@ -19,6 +19,12 @@ export interface FlatRecallOptions {
     maxPinnedTokens: number;
 }
 
+// Per-note <note kind=… intent=… hit_count=… pinned=…><delta>…</delta></note>
+// framing that budgetFill's delta-only estimate would otherwise ignore (~80
+// chars ≈ 20 tokens/note). Counting it keeps the rendered block within max_tokens
+// instead of overshooting ~13% on a 10-note block (rev-1 S1).
+const NOTE_FRAMING_TOKENS = 20;
+
 // Rough token estimate: 1 token ≈ 4 chars (conservative for XML overhead)
 function estimateTokens(text: string): number {
     return Math.ceil(text.length / 4);
@@ -115,11 +121,15 @@ function budgetFill(
     const result: SkillMemoryNote[] = [];
     let pinnedTokens = 0;
     let totalTokens = 0;
+    // The total budget is the hard ceiling, so the pinned sub-budget can never
+    // exceed it — clamp so the default max_pinned_tokens (4000) > max_tokens
+    // (1500) can't imply pinned notes get more room than the whole block (rev-2).
+    const effectiveMaxPinned = Math.min(maxPinnedTokens, maxTokens);
 
     for (const note of notes) {
-        const tokens = estimateTokens(note.delta);
+        const tokens = estimateTokens(note.delta) + NOTE_FRAMING_TOKENS;
         if (note.pinned === 1) {
-            if (pinnedTokens + tokens > maxPinnedTokens) continue;
+            if (pinnedTokens + tokens > effectiveMaxPinned) continue;
             pinnedTokens += tokens;
         }
         if (totalTokens + tokens > maxTokens) continue;

packages/plugin/src/tools/ctx-skill-recall/tools.ts

@@ -1,4 +1,5 @@
 import { readFileSync } from "node:fs";
+import { dirname } from "node:path";
 import { type ToolContext, type ToolDefinition, tool } from "@opencode-ai/plugin";
 import { resolveProjectIdentity } from "../../features/magic-context/memory/project-identity";
 import { parseFrontmatterConfig } from "../../features/magic-context/skill-memory/frontmatter";
@@ -159,8 +160,9 @@ export function createCtxSkillRecallTool(deps: CtxSkillRecallToolDeps): ToolDefi
                 frontmatterConfig = rawSkillContent
                     ? parseFrontmatterConfig(rawSkillContent)
                     : null;
-                // Derive tier from resolved path
-                tier = deriveSkillTier(resolvedPath.replace("/SKILL.md", ""));
+                // Derive tier from the skill's directory (dirname, not a fragile
+                // string replace that would mis-handle a path containing "SKILL.md").
+                tier = deriveSkillTier(dirname(resolvedPath));
             }
 
             if (!frontmatterConfig?.enabled) {