portable-agent-layer 0.63.2 → 0.64.0

package/assets/templates/PAL/SYSTEM_ARCHITECTURE.md

@@ -213,6 +213,9 @@ Brief description.
 
 ┌─────────────────────┐
 │  User Prompt Submit │──► UserPromptOrchestrator.ts
+│                     │    - Prompt context (one merged system-reminder):
+│                     │      contextual steering, skill trigger matches,
+│                     │      prior-lesson retrieval
 │                     │    - Rating capture (explicit/implicit)
 │                     │    - Session naming (first prompt)
 └─────────────────────┘

package/assets/templates/pal-settings.json

@@ -27,6 +27,7 @@
     "handoff": true,
     "selfModel": true,
     "contextualSteering": true,
+    "skillMatching": true,
     "steeringTestReport": false
   },
   "steering": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "portable-agent-layer",
-  "version": "0.63.2",
+  "version": "0.64.0",
   "description": "PAL — Portable Agent Layer: persistent personal context for AI coding assistants",
   "type": "module",
   "bin": {

package/src/cli/index.ts

@@ -17,7 +17,7 @@
  *   doctor                            Check prerequisites and system health
  *   usage                             Summarize token usage and cost
  *   skill link <name>                 Link a personal ~/.pal/skills/<name>/ into installed agents
- *   skill doctor <name>               Evaluate a skill against the authoring best practices
+ *   skill doctor <name|--all>         Evaluate one skill, or every installed skill, against the authoring best practices
  *   subagent link <name>             Install a personal ~/.pal/agents/<name>.md into installed agents
  *   subagent doctor <name>           Evaluate a subagent against the authoring best practices
  *   debug [on|off]                    Enable / disable verbose hook debug logging
@@ -283,7 +283,7 @@ function showHelp() {
     pal cli knowledge <sub> [args]          Query & manage the knowledge store
                                             (search · graph · stats · hubs · find · show · add · ls)
     pal cli skill link <name>               Link a personal ~/.pal/skills/<name>/ into installed agents
-    pal cli skill doctor <name>             Evaluate a skill against the authoring best practices
+    pal cli skill doctor <name|--all>       Evaluate one skill, or every installed skill
     pal cli skill author-model              Print the flagship model that authors skills for the active agent
     pal cli subagent link <name>            Install a personal ~/.pal/agents/<name>.md into installed agents
     pal cli subagent doctor <name>          Evaluate a subagent against the authoring best practices

package/src/cli/skill.ts

@@ -5,16 +5,59 @@
  *                                 every installed agent so it is discoverable.
  *   pal cli skill doctor <name>   Evaluate ~/.pal/skills/<name>/ against the
  *                                 skill-authoring best practices.
+ *   pal cli skill doctor --all    Evaluate every installed skill, one line each.
  *   pal cli skill author-model    Print the flagship model configured to author
  *                                 skills for the active agent (empty if none).
  */
 
+import { existsSync, readdirSync, statSync } from "node:fs";
 import { resolve } from "node:path";
 import { getActiveAgent } from "../hooks/lib/agent";
 import { flagshipAuthorModel } from "../hooks/lib/models";
 import { palHome } from "../hooks/lib/paths";
 import { linkPersonalSkill, log } from "../targets/lib";
-import { formatReport, lintSkill } from "../tools/skill-doctor";
+import { formatReport, formatSummary, lintSkill } from "../tools/skill-doctor";
+
+/** Entry names under ~/.pal/skills/, sorted; dangling links included. */
+function skillEntries(dir: string): string[] {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).sort();
+}
+
+/** A listed entry that does not exist can only be a symlink whose target is gone. */
+function isDanglingLink(path: string): boolean {
+  return !existsSync(path);
+}
+
+/** Lint every installed skill, one summary line each. Exits 1 if any has errors. */
+function doctorAll(): number {
+  const dir = resolve(palHome(), "skills");
+  const entries = skillEntries(dir);
+
+  for (const name of entries.filter((n) => isDanglingLink(resolve(dir, n)))) {
+    log.warn(`Skipped ${name}: link target is gone — run 'pal cli install' to prune it`);
+  }
+
+  const names = entries.filter((n) => {
+    const path = resolve(dir, n);
+    return !isDanglingLink(path) && statSync(path).isDirectory();
+  });
+  if (names.length === 0) {
+    log.warn(`No skills found in ${dir}`);
+    return 0;
+  }
+
+  const reports = names.map((n) => lintSkill(resolve(dir, n)));
+  for (const report of reports) console.log(formatSummary(report));
+
+  const failing = reports.filter((r) => r.errors > 0).length;
+  const warning = reports.filter((r) => r.errors === 0 && r.warnings > 0).length;
+  const clean = reports.length - failing - warning;
+  console.log(
+    `\n${reports.length} skills — ${failing} failing, ${warning} with warnings, ${clean} clean`
+  );
+  return failing > 0 ? 1 : 0;
+}
 
 export async function runSkill(args: string[]): Promise<number> {
   const [sub, name] = args;
@@ -26,8 +69,9 @@ export async function runSkill(args: string[]): Promise<number> {
   }
 
   if (sub === "doctor") {
+    if (name === "--all") return doctorAll();
     if (!name) {
-      log.error("Usage: pal cli skill doctor <name>");
+      log.error("Usage: pal cli skill doctor <name|--all>");
       return 1;
     }
     const report = lintSkill(resolve(palHome(), "skills", name));
@@ -60,6 +104,6 @@ export async function runSkill(args: string[]): Promise<number> {
     }
   }
 
-  log.error("Usage: pal cli skill <link|doctor|author-model> [name]");
+  log.error("Usage: pal cli skill <link|doctor|author-model> [name|--all]");
   return 1;
 }

package/src/hooks/handlers/inject-retrieval.ts

@@ -3,8 +3,8 @@
  *
  * Called from UserPromptOrchestrator. Reads the retrieval index, ranks the prompt
  * against the corpus, prints a `<system-reminder>` block to stdout (Claude Code
- * prepends UserPromptSubmit hook stdout to the prompt). Fail-closed: any error or
- * timeout produces empty output, never blocks the prompt.
+ * prepends UserPromptSubmit hook stdout to the prompt). Fail-closed: any error
+ * produces empty output, never blocks the prompt.
  */
 
 import { isCodex, isCursor } from "../lib/agent";
@@ -12,35 +12,41 @@ import { logDebug, logError } from "../lib/log";
 import { runRetrieval } from "../lib/retrieval";
 import { ensureIndex } from "../lib/retrieval-index";
 import { isEnabled } from "../lib/settings";
+import { getSkillReminder } from "../lib/skill-match";
 import { getSteeringReminder } from "../lib/steering";
 
-const TIMEOUT_MS = 250;
+const BUDGET_MS = 250;
 
-function withTimeout<T>(work: () => T, ms: number): Promise<T | null> {
-  return new Promise((resolve) => {
-    const timer = setTimeout(() => resolve(null), ms);
-    try {
-      const result = work();
-      clearTimeout(timer);
-      resolve(result);
-    } catch (err) {
-      clearTimeout(timer);
-      logError("inject-retrieval", err);
-      resolve(null);
+/** Run sync work on the prompt path, containing any throw. A synchronous call cannot
+ *  be preempted on a single thread, so the budget is measured and logged, never
+ *  enforced — an overrun still returns its result rather than being discarded.
+ *  @lintignore exported for test/inject-retrieval.test.ts */
+export function withinBudget<T>(work: () => T, ms: number): T | null {
+  const started = performance.now();
+  try {
+    return work();
+  } catch (err) {
+    logError("inject-retrieval", err);
+    return null;
+  } finally {
+    const elapsed = performance.now() - started;
+    if (elapsed > ms) {
+      logDebug("inject-retrieval", `over budget: ${elapsed.toFixed(0)}ms > ${ms}ms`);
     }
-  });
+  }
 }
 
-/** Returns the retrieval reminder string, or null if nothing to inject. @lintignore dynamically imported by opencode plugin */
+/** Returns the retrieval reminder string, or null if nothing to inject.
+ *  @lintignore exercised directly by test/inject-retrieval.test.ts */
 export async function getRetrievalReminder(prompt: string): Promise<string | null> {
   if (!prompt?.trim()) return null;
   if (!isEnabled("learningInjection")) return null;
 
-  const result = await withTimeout(() => {
+  const result = withinBudget(() => {
     const index = ensureIndex();
     if (index.corpusSize === 0) return null;
     return runRetrieval(prompt, index, process.cwd());
-  }, TIMEOUT_MS);
+  }, BUDGET_MS);
 
   if (!result?.reminder) return null;
 
@@ -73,15 +79,23 @@ function writeForAgent(reminder: string): void {
   }
 }
 
-/** Gather all prompt-time context — prior-lesson retrieval + contextual steering —
- *  merge into a single payload, and do the one per-agent write. Returns the combined
- *  reminder that was injected, or null if there was nothing to inject. */
+/** Merge every prompt-time source — contextual steering, skill matches, prior-lesson
+ *  retrieval — into one payload, or null when none of them produced anything.
+ *  @lintignore dynamically imported by opencode plugin */
+export async function getPromptContext(prompt: string): Promise<string | null> {
+  const parts = [
+    getSteeringReminder(prompt),
+    getSkillReminder(prompt),
+    await getRetrievalReminder(prompt),
+  ].filter((p): p is string => Boolean(p));
+
+  return parts.length > 0 ? parts.join("\n\n") : null;
+}
+
+/** Gather all prompt-time context and do the one per-agent write. Returns the
+ *  combined reminder that was injected, or null if there was nothing to inject. */
 export async function injectPromptContext(prompt: string): Promise<string | null> {
-  const retrieval = await getRetrievalReminder(prompt);
-  const steering = getSteeringReminder(prompt);
-  const parts = [steering, retrieval].filter((p): p is string => Boolean(p));
-  if (parts.length === 0) return null;
-  const combined = parts.join("\n\n");
-  writeForAgent(combined);
+  const combined = await getPromptContext(prompt);
+  if (combined) writeForAgent(combined);
   return combined;
 }

package/src/hooks/lib/readme-sync.ts

@@ -79,15 +79,30 @@ function extractEnvVars(): string[] {
   return [...vars];
 }
 
-/** Extract skill names from assets/skills/ */
-function extractSkillNames(): string[] {
-  const pkg = palPkg();
-  const skillsDir = resolve(pkg, "assets", "skills");
+/**
+ * Names of the skills PAL ships — one directory per skill, each holding a
+ * SKILL.md. Reading the directory rather than loose `.md` files matters: the
+ * folder-per-skill layout is what the runtime loads, and matching on files
+ * silently yields nothing, which makes every skill check pass vacuously.
+ */
+export function shippedSkillNames(): string[] {
+  const skillsDir = resolve(palPkg(), "assets", "skills");
   if (!existsSync(skillsDir)) return [];
 
-  return readdirSync(skillsDir)
-    .filter((f) => f.endsWith(".md"))
-    .map((f) => f.replace(/\.md$/, ""));
+  return readdirSync(skillsDir, { withFileTypes: true })
+    .filter((e) => e.isDirectory() && existsSync(resolve(skillsDir, e.name, "SKILL.md")))
+    .map((e) => e.name)
+    .sort();
+}
+
+/**
+ * Skill names the README's "## Skills" table claims PAL ships. Scoped to that
+ * one section: other tables list commands and agents in the same row shape, and
+ * matching them would report every command as a retired skill.
+ */
+function documentedSkillNames(readme: string): string[] {
+  const section = /^## Skills$([\s\S]*?)(?=^## )/m.exec(readme)?.[1] ?? "";
+  return Array.from(section.matchAll(/^\|\s*`([a-z0-9-]+)`\s*\|/gm), (m) => m[1]);
 }
 
 /** Validate that README.md documents all code surfaces. */
@@ -118,12 +133,17 @@ export function validateReadmeSync(): SyncResult {
     }
   }
 
-  // Check skills — just verify the count is mentioned or each name appears
-  const skills = extractSkillNames();
-  const undocumentedSkills = skills.filter((name) => !readme.includes(name));
+  // Check skills — every shipped skill has a row, and no row outlives its skill
+  const shipped = shippedSkillNames();
+  const undocumentedSkills = shipped.filter((name) => !readme.includes(name));
   if (undocumentedSkills.length > 0) {
     issues.push(`Skills not documented in README: ${undocumentedSkills.join(", ")}`);
   }
 
+  const retired = documentedSkillNames(readme).filter((name) => !shipped.includes(name));
+  if (retired.length > 0) {
+    issues.push(`README documents skills that no longer ship: ${retired.join(", ")}`);
+  }
+
   return { ok: issues.length === 0, issues };
 }

package/src/hooks/lib/skill-match.ts

@@ -0,0 +1,129 @@
+/**
+ * Skill matching — deterministic trigger lookup that names the skills a prompt
+ * probably wants, injected at prompt time.
+ *
+ * A skill declares its own `metadata.triggers` in SKILL.md; `generateSkillIndex`
+ * copies them into skill-index.json. Here the prompt and every trigger are
+ * normalized the same way (lowercase, punctuation to spaces, space-padded), so a
+ * plain substring test is already a whole-word test and multi-word phrases work
+ * without a regex. Pure + fail-open, like the steering classifier it rides with.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { paths } from "./paths";
+import { isEnabled } from "./settings";
+
+interface SkillIndexEntry {
+  name: string;
+  description: string;
+  triggers?: string[];
+}
+
+export interface SkillIndex {
+  skills: Record<string, SkillIndexEntry>;
+}
+
+export interface SkillMatch {
+  name: string;
+  description: string;
+  score: number;
+  matched: string[];
+}
+
+const MAX_MATCHES = 3;
+const MAX_SKILL_BYTES = 700;
+const MAX_DESCRIPTION_CHARS = 100;
+const PHRASE_WEIGHT = 3;
+const WORD_WEIGHT = 1;
+
+/** Lowercase, punctuation to spaces, space-padded — so `includes` tests whole words. */
+function normalize(text: string): string {
+  return ` ${text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, " ")
+    .trim()} `;
+}
+
+function readSkillIndex(): SkillIndex | null {
+  const path = resolve(paths.state(), "skill-index.json");
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8")) as SkillIndex;
+  } catch {
+    return null;
+  }
+}
+
+function weightOf(trigger: string): number {
+  return trigger.trim().includes(" ") ? PHRASE_WEIGHT : WORD_WEIGHT;
+}
+
+/** Rank the indexed skills whose triggers appear in the prompt, best first. */
+export function matchSkills(prompt: string, index: SkillIndex): SkillMatch[] {
+  const haystack = normalize(prompt);
+  if (haystack.trim() === "") return [];
+
+  const matches: SkillMatch[] = [];
+  for (const entry of Object.values(index.skills ?? {})) {
+    let score = 0;
+    const matched: string[] = [];
+    for (const trigger of entry.triggers ?? []) {
+      const needle = normalize(trigger);
+      if (needle.trim() === "" || !haystack.includes(needle)) continue;
+      score += weightOf(needle);
+      matched.push(trigger);
+    }
+    if (score > 0)
+      matches.push({ name: entry.name, description: entry.description, score, matched });
+  }
+
+  return matches
+    .sort((a, b) => b.score - a.score || a.name.localeCompare(b.name))
+    .slice(0, MAX_MATCHES);
+}
+
+function summarize(description: string): string {
+  if (description.length <= MAX_DESCRIPTION_CHARS) return description;
+  return `${description.slice(0, MAX_DESCRIPTION_CHARS).trimEnd()}…`;
+}
+
+function line(match: SkillMatch): string {
+  const matched = match.matched.map((trigger) => `"${trigger}"`).join(", ");
+  return `- ${match.name} — ${summarize(match.description)} (matched: ${matched})`;
+}
+
+/** Build the skill-match <system-reminder> for a prompt, or null if nothing matches. */
+export function getSkillReminder(prompt: string): string | null {
+  if (!isEnabled("skillMatching")) return null;
+  if (!prompt?.trim()) return null;
+
+  const index = readSkillIndex();
+  if (!index) return null;
+
+  let matches: SkillMatch[];
+  try {
+    matches = matchSkills(prompt, index);
+  } catch {
+    return null; // fail-open: never block a prompt on a matcher error
+  }
+  if (matches.length === 0) return null;
+
+  const lines: string[] = [];
+  let budget = MAX_SKILL_BYTES;
+  for (const match of matches) {
+    const rendered = line(match);
+    const cost = Buffer.byteLength(rendered);
+    if (cost > budget) break; // byte-cap: drop the overflow tail, keep top matches
+    lines.push(rendered);
+    budget -= cost;
+  }
+  if (lines.length === 0) return null;
+
+  return [
+    "<system-reminder>",
+    "Potential matching skills: these matched trigger words in your prompt. Invoke one with the Skill tool if it fits the request; ignore them if none do.",
+    ...lines,
+    "</system-reminder>",
+  ].join("\n");
+}

package/src/hooks/lib/skill-triggers.ts

@@ -0,0 +1,82 @@
+/**
+ * SKILL.md trigger declarations — the words and phrases a prompt carries when it
+ * wants a given skill.
+ *
+ * `metadata` is the only frontmatter key Anthropic's skill spec reserves for
+ * third-party tooling, so triggers live under it; a top-level `triggers:` key
+ * fails skill packaging with an unexpected-key error. Shared by the skill-index
+ * generator (which publishes them) and the skill doctor (which warns when a
+ * skill declares none).
+ */
+
+/** Indented lines belonging to the frontmatter `metadata:` map, or [] when absent. */
+function metadataBlock(frontmatter: string): string[] {
+  const lines = frontmatter.split("\n");
+  const start = lines.findIndex((line) => /^metadata:\s*$/.test(line));
+  if (start === -1) return [];
+
+  const block: string[] = [];
+  for (const line of lines.slice(start + 1)) {
+    if (line.trim() === "") continue;
+    if (!/^\s/.test(line)) break;
+    block.push(line);
+  }
+  return block;
+}
+
+/** Normalize one authored trigger: unquote, collapse whitespace, lowercase. */
+function normalizeTrigger(raw: string): string {
+  return raw
+    .trim()
+    .replace(/^["']|["']$/g, "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .toLowerCase();
+}
+
+/** Split a YAML flow sequence — `["a", "b"]` or `[a, b]` — into its items. */
+function splitFlowSequence(value: string): string[] {
+  try {
+    const parsed: unknown = JSON.parse(value);
+    if (Array.isArray(parsed)) return parsed.map((item) => String(item));
+  } catch {
+    /* not strict JSON — fall through to the permissive split */
+  }
+  return value.slice(1, -1).split(",");
+}
+
+/** Items of a YAML block sequence: the `- item` lines directly under a key. */
+function blockSequenceItems(lines: string[]): string[] {
+  const items: string[] = [];
+  for (const line of lines) {
+    const item = /^\s*-\s+(.*)$/.exec(line);
+    if (!item) break;
+    items.push(item[1]);
+  }
+  return items;
+}
+
+/**
+ * Author-declared `metadata.triggers` — the words and phrases a prompt is matched
+ * against. Accepts either YAML shape:
+ *
+ *   metadata:            |   metadata:
+ *     triggers:          |     triggers: ["make a deck", "slides"]
+ *       - make a deck    |
+ *       - slides         |
+ *
+ * `metadata` is the only frontmatter key Anthropic's skill spec reserves for
+ * third-party tooling; a top-level `triggers:` key fails skill packaging.
+ */
+export function declaredTriggers(frontmatter: string): string[] {
+  const block = metadataBlock(frontmatter);
+  const at = block.findIndex((line) => /^\s*triggers:/.test(line));
+  if (at === -1) return [];
+
+  const inline = /^\s*triggers:\s*(\S.*)$/.exec(block[at])?.[1];
+  const raw = inline
+    ? splitFlowSequence(inline)
+    : blockSequenceItems(block.slice(at + 1));
+
+  return [...new Set(raw.map(normalizeTrigger).filter(Boolean))];
+}

package/src/targets/lib.ts

@@ -10,14 +10,16 @@ import {
   mkdirSync,
   readdirSync,
   readFileSync,
+  readlinkSync,
   rmSync,
   symlinkSync,
   unlinkSync,
   writeFileSync,
 } from "node:fs";
 import { homedir } from "node:os";
-import { resolve } from "node:path";
+import { dirname, resolve, sep } from "node:path";
 import { assets, palHome, platform } from "../hooks/lib/paths";
+import { declaredTriggers } from "../hooks/lib/skill-triggers";
 
 // --- Colored logging ---
 
@@ -775,6 +777,10 @@ export function copySkills(claudeSkillsDir: string): number {
   const linkType = process.platform === "win32" ? "junction" : "dir";
   let count = 0;
 
+  for (const name of pruneStaleSkillLinks(claudeSkillsDir)) {
+    log.info(`Removed stale skill link: ${name}`);
+  }
+
   for (const name of readdirSync(skillsDir)) {
     const srcDir = resolve(skillsDir, name);
     if (!existsSync(resolve(srcDir, "SKILL.md"))) continue;
@@ -797,6 +803,55 @@ export function copySkills(claudeSkillsDir: string): number {
   return count;
 }
 
+/** True when `link` is a symlink whose target no longer exists. */
+function isDanglingSymlink(link: string): boolean {
+  try {
+    return lstatSync(link).isSymbolicLink() && !existsSync(link);
+  } catch {
+    return false;
+  }
+}
+
+/** True when the symlink at `link` points at `root` or somewhere beneath it. */
+function symlinkPointsInto(link: string, root: string): boolean {
+  try {
+    const target = resolve(dirname(link), readlinkSync(link));
+    return target === root || target.startsWith(root + sep);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Remove discovery links left behind when a shipped skill is renamed or
+ * retired. Ownership is read from where a link points, not from metadata:
+ * a dead link has no SKILL.md to read, but its target path still says
+ * whether PAL created it.
+ *
+ *   ~/.pal/skills/<name>   → pruned when dangling and pointing into assets/skills/
+ *   <agent>/skills/<name>  → pruned when dangling and pointing into ~/.pal/skills/
+ *
+ * Personal skills are real directories, so they are never candidates, and a
+ * user's own symlinks to anywhere else are left alone even when broken.
+ */
+function pruneStaleSkillLinks(agentSkillsDir: string): string[] {
+  const ownedTrees = [
+    { dir: PAL_SKILLS_DIR, root: assets.skills() },
+    { dir: agentSkillsDir, root: PAL_SKILLS_DIR },
+  ];
+  const removed: string[] = [];
+  for (const { dir, root } of ownedTrees) {
+    if (!existsSync(dir)) continue;
+    for (const name of readdirSync(dir)) {
+      const link = resolve(dir, name);
+      if (!isDanglingSymlink(link) || !symlinkPointsInto(link, root)) continue;
+      unlinkSync(link);
+      removed.push(name);
+    }
+  }
+  return removed;
+}
+
 /**
  * Agent skills directories that need a per-skill discovery link.
  *
@@ -1319,7 +1374,7 @@ interface SkillIndex {
   skills: Record<string, SkillIndexEntry>;
 }
 
-/** Extract trigger keywords from a skill description */
+/** Fallback triggers for a skill that declares none: keywords mined from its description. */
 function extractTriggers(description: string): string[] {
   // Extract "Use when ..." phrases and key terms
   const triggers = new Set<string>();
@@ -1378,10 +1433,12 @@ export function generateSkillIndex(): number {
       const skillName = nameMatch[1].trim();
       const description = descMatch?.[1]?.trim() ?? "";
 
+      const declared = declaredTriggers(fm);
+
       index.skills[skillName] = {
         name: skillName,
         description,
-        triggers: extractTriggers(description),
+        triggers: declared.length > 0 ? declared : extractTriggers(description),
       };
       index.totalSkills++;
     } catch {

package/src/targets/opencode/plugin.ts

@@ -63,11 +63,9 @@ const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
   const { captureRating } = await lib<typeof import("../../hooks/handlers/rating")>(
     "../handlers/rating.ts"
   );
-  const { getRetrievalReminder } = await lib<
+  const { getPromptContext } = await lib<
     typeof import("../../hooks/handlers/inject-retrieval")
   >("../handlers/inject-retrieval.ts");
-  const { getSteeringReminder } =
-    await lib<typeof import("../../hooks/lib/steering")>("steering.ts");
 
   function partsToText(parts: Array<Record<string, unknown>>): string {
     return parts
@@ -163,9 +161,7 @@ const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
       const text = partsToText(output.parts ?? []);
       if (!text.trim()) return;
 
-      const retrieval = await getRetrievalReminder(text);
-      const steering = getSteeringReminder(text);
-      const injectedText = [steering, retrieval].filter(Boolean).join("\n\n");
+      const injectedText = (await getPromptContext(text)) ?? "";
       logPromptSnapshot(text, injectedText || null);
 
       await Promise.allSettled([