portable-agent-layer 0.23.0 → 0.24.0

package/assets/templates/PAL/ALGORITHM.md

@@ -216,7 +216,26 @@ Only add threads that genuinely need follow-up. Resolve existing threads if this
 bun ~/.pal/tools/thread.ts --resolve --id <id>
 ```
 
-**4. Wisdom Frame** (Extended+ only) — if the session produced a genuine, reusable insight:
+**4. Opinion capture** — scan the conversation for moments where the user:
+- Confirmed something you did: "yes exactly", "keep doing that", "10 rated", accepted without pushback
+- Corrected something you did: "no", "don't do that", "stop", "that's not what I meant"
+- Revealed a preference by repeating a pattern (asked for concise answers twice, always checked PAI first, etc.)
+
+For each, invoke the opinion tool:
+```bash
+# User confirmed a preference
+bun ~/.pal/skills/opinion/tools/opinion.ts evidence "matching keywords" --confirmation "what they confirmed"
+
+# User corrected a preference
+bun ~/.pal/skills/opinion/tools/opinion.ts evidence "matching keywords" --contradiction "what they corrected"
+
+# New pattern observed (no existing opinion matches)
+bun ~/.pal/skills/opinion/tools/opinion.ts add "the preference" --category communication|technical|workflow|general
+```
+
+Skip if nothing in the conversation touched preferences or working style.
+
+**5. Wisdom Frame** (Extended+ only) — if the session produced a genuine, reusable insight:
 
 ```bash
 bun ~/.pal/tools/wisdom-frame.ts --domain <domain> --observation "insight" [--type principle|contextual-rule|anti-pattern|evolution]

package/assets/templates/pal-settings.json

@@ -30,6 +30,7 @@
     "activeWork": true,
     "projectHistory": true,
     "sessionIntelligence": true,
-    "handoff": true
+    "handoff": true,
+    "selfModel": true
   }
 }

package/package.json

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

package/src/cli/setup-identity.ts

@@ -3,43 +3,19 @@
  * Called during `pal install`. Skips fields that already have values.
  */
 
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
 import * as clack from "@clack/prompts";
-import { palHome } from "../hooks/lib/paths";
-
-interface PalSettings {
-  identity?: {
-    ai?: { name?: string; fullName?: string; displayName?: string; catchphrase?: string };
-    principal?: { name?: string; timezone?: string };
-  };
-  [key: string]: unknown;
-}
-
-function settingsPath(): string {
-  return resolve(palHome(), "memory", "pal-settings.json");
-}
-
-function readSettings(): PalSettings {
-  const p = settingsPath();
-  if (!existsSync(p)) return {};
-  try {
-    return JSON.parse(readFileSync(p, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-
-function writeSettings(settings: PalSettings): void {
-  writeFileSync(settingsPath(), `${JSON.stringify(settings, null, 2)}\n`, "utf-8");
-}
+import {
+  type PalSettingsData,
+  raw as readSettings,
+  write as writeSettings,
+} from "../hooks/lib/settings";
 
 /** Prompt for missing identity fields. Skips any field that already has a value. */
 export async function promptIdentity(): Promise<void> {
   // Skip interactive prompts in non-TTY environments (tests, CI)
   if (!process.stdin.isTTY) return;
 
-  const settings = readSettings();
+  const settings: PalSettingsData = { ...readSettings() };
   if (!settings.identity) settings.identity = {};
   if (!settings.identity.ai) settings.identity.ai = {};
   if (!settings.identity.principal) settings.identity.principal = {};

package/src/hooks/handlers/failure.ts

@@ -30,7 +30,8 @@ export async function captureFailure(
   rating: number,
   context: string,
   transcript: string,
-  detailedContext?: string
+  detailedContext?: string,
+  principle?: string
 ): Promise<void> {
   const messages = parseMessages(transcript);
 
@@ -55,6 +56,7 @@ export async function captureFailure(
     ts: new Date().toISOString(),
     slug,
   };
+  if (principle) meta.principle = principle;
 
   const body = [
     "## What Happened",

package/src/hooks/handlers/rating.ts

@@ -166,8 +166,16 @@ const SENTIMENT_SCHEMA = {
     confidence: { type: "number" },
     summary: { type: "string" },
     detailed_context: { type: "string" },
+    principle: { type: "string" },
   },
-  required: ["rating", "sentiment", "confidence", "summary", "detailed_context"],
+  required: [
+    "rating",
+    "sentiment",
+    "confidence",
+    "summary",
+    "detailed_context",
+    "principle",
+  ],
   additionalProperties: false,
 } as const;
 
@@ -177,6 +185,7 @@ interface SentimentResult {
   confidence: number;
   summary: string;
   detailed_context: string;
+  principle: string;
 }
 
 const SENTIMENT_SYSTEM_PROMPT = `Analyze the user's message for emotional sentiment toward the AI assistant.
@@ -187,7 +196,8 @@ OUTPUT FORMAT (JSON only):
   "sentiment": "positive" | "negative" | "neutral",
   "confidence": <0.0-1.0>,
   "summary": "<brief explanation, 10 words max>",
-  "detailed_context": "<comprehensive analysis, 50-150 words>"
+  "detailed_context": "<comprehensive analysis, 50-150 words>",
+  "principle": "<one actionable rule the AI should follow to avoid this failure or repeat this success, 10-20 words. Start with a verb: 'Verify...', 'Always...', 'Never...', 'Ask before...'>"
 }
 
 DETAILED_CONTEXT REQUIREMENTS:
@@ -240,6 +250,7 @@ function handleRating(
   context: string,
   source: string,
   detailedContext?: string,
+  principle?: string,
   sessionId?: string,
   userMessage?: string
 ): void {
@@ -257,6 +268,7 @@ function handleRating(
           context,
           source,
           detailedContext,
+          principle,
           responsePreview,
           userPreview,
           ts: now(),
@@ -284,6 +296,7 @@ async function handleImplicitSentiment(
       `Direct praise: "${trimmed}"`,
       "implicit",
       undefined,
+      undefined,
       sessionId,
       trimmed
     );
@@ -328,6 +341,7 @@ async function handleImplicitSentiment(
         `${parsed.summary}: ${trimmed.slice(0, 200)}`,
         "implicit",
         parsed.detailed_context,
+        parsed.principle,
         sessionId,
         trimmed
       );
@@ -352,6 +366,7 @@ export async function captureRating(message: string, sessionId?: string): Promis
       explicit.comment || cleaned.slice(0, 200),
       "explicit",
       undefined,
+      undefined,
       sessionId,
       cleaned
     );

package/src/hooks/handlers/reflect-trigger.ts

@@ -1,7 +1,7 @@
 /**
  * Auto-trigger for relationship reflect — runs when conditions are met:
- * - 7+ days since last reflect
- * - 10+ new relationship notes since last reflect
+ * - 1+ days since last reflect
+ * - 5+ new relationship notes since last reflect
  *
  * Spawns `bun run tool:reflect` as a detached background process.
  */
@@ -12,8 +12,8 @@ import { logDebug } from "../lib/log";
 import { getLastReflectDate } from "../lib/opinions";
 import { palPkg, paths } from "../lib/paths";
 
-const MIN_DAYS_BETWEEN = 7;
-const MIN_NEW_NOTES = 10;
+const MIN_DAYS_BETWEEN = 1;
+const MIN_NEW_NOTES = 5;
 
 function countNotesSince(since: string): number {
   const relDir = paths.relationship();

package/src/hooks/handlers/self-model-trigger.ts

@@ -0,0 +1,27 @@
+/**
+ * Auto-trigger for self-model synthesis — runs daily.
+ * writeSelfModel has a 24h TTL guard, so this is safe to call every session.
+ * Respects dynamicContext.selfModel — if disabled, skips generation entirely.
+ */
+
+import { writeSelfModel } from "../../tools/self-model";
+import { logDebug } from "../lib/log";
+import { isEnabled } from "../lib/settings";
+
+export async function checkSelfModelTrigger(): Promise<void> {
+  if (!isEnabled("selfModel")) {
+    logDebug("self-model-trigger", "Disabled in pal-settings.json");
+    return;
+  }
+
+  try {
+    const result = await writeSelfModel(30);
+    if (result.skipped) {
+      logDebug("self-model-trigger", "Skipped — last synthesis < 24h ago");
+    } else {
+      logDebug("self-model-trigger", `Self-model written: ${result.path}`);
+    }
+  } catch {
+    // Non-critical — self-model is best-effort
+  }
+}

package/src/hooks/lib/claude-md.ts

@@ -18,7 +18,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { dirname, relative, resolve } from "node:path";
-import { assets, ensureDir, palHome, paths, platform } from "./paths";
+import { assets, ensureDir, paths, platform } from "./paths";
 import { buildSetupPrompt, readSetupState } from "./setup";
 
 const TEMPLATE_PATH = assets.agentsMdTemplate();
@@ -89,7 +89,7 @@ export function needsRebuild(): boolean {
   const sources: string[] = [
     TEMPLATE_PATH,
     resolve(paths.state(), "setup.json"),
-    palSettingsPath(),
+    resolve(paths.memory(), "pal-settings.json"),
   ];
 
   // Track PAL doc sources for rebuild detection
@@ -103,46 +103,7 @@ export function needsRebuild(): boolean {
   return latestMtime(...sources) > outputMtime;
 }
 
-interface Identity {
-  ai: { name: string; displayName: string; catchphrase: string };
-  principal: { name: string };
-}
-
-const IDENTITY_DEFAULTS: Identity = {
-  ai: { name: "Assistant", displayName: "ASSISTANT", catchphrase: "" },
-  principal: { name: "" },
-};
-
-function palSettingsPath(): string {
-  return resolve(palHome(), "memory", "pal-settings.json");
-}
-
-/** Load identity from pal-settings.json */
-export function loadIdentity(): Identity {
-  const p = palSettingsPath();
-  if (!existsSync(p)) return IDENTITY_DEFAULTS;
-
-  try {
-    const data = JSON.parse(readFileSync(p, "utf-8"));
-    const ai = data.identity?.ai ?? {};
-    const principal = data.identity?.principal ?? {};
-    const name = ai.name || IDENTITY_DEFAULTS.ai.name;
-    const catchphrase = (ai.catchphrase || "").replace("{name}", name);
-
-    return {
-      ai: {
-        name,
-        displayName: ai.displayName || IDENTITY_DEFAULTS.ai.displayName,
-        catchphrase,
-      },
-      principal: {
-        name: principal.name || IDENTITY_DEFAULTS.principal.name,
-      },
-    };
-  } catch {
-    return IDENTITY_DEFAULTS;
-  }
-}
+import { identity } from "./settings";
 
 /** Render AGENTS.md from the template using current state */
 export function buildClaudeMd(): string {
@@ -152,14 +113,14 @@ export function buildClaudeMd(): string {
 
   const state = readSetupState();
   const setupPrompt = state ? buildSetupPrompt(state) : null;
-  const identity = loadIdentity();
+  const id = identity();
 
   return template
     .replace("{{SETUP_PROMPT}}", setupPrompt ? `${setupPrompt}\n` : "")
-    .replaceAll("{{IDENTITY_NAME}}", identity.ai.name)
-    .replaceAll("{{IDENTITY_DISPLAY}}", identity.ai.displayName)
-    .replaceAll("{{IDENTITY_CATCHPHRASE}}", identity.ai.catchphrase)
-    .replaceAll("{{PRINCIPAL_NAME}}", identity.principal.name);
+    .replaceAll("{{IDENTITY_NAME}}", id.ai.name)
+    .replaceAll("{{IDENTITY_DISPLAY}}", id.ai.displayName)
+    .replaceAll("{{IDENTITY_CATCHPHRASE}}", id.ai.catchphrase)
+    .replaceAll("{{PRINCIPAL_NAME}}", id.principal.name);
 }
 
 /** Regenerate AGENTS.md if any source file is newer, and ensure CLAUDE.md symlink exists. Returns true if rebuilt. */

package/src/hooks/lib/context.ts

@@ -12,36 +12,16 @@ import { loadOpinionContext } from "./opinions";
 import { paths } from "./paths";
 import { loadRecentNotes } from "./relationship";
 import { readSessionNames } from "./session-names";
+import * as settings from "./settings";
 import { buildSetupPrompt, readSetupState, remainingSteps, STEP_ORDER } from "./setup";
 import { computeSignalTrends, formatTrends } from "./signal-trends";
 import { readFramePrinciples } from "./wisdom";
 import { readProjectHistory, readSessions, recentSessions } from "./work-tracking";
 
-interface PalSettings {
-  loadAtStartup?: { files?: string[] };
-  dynamicContext?: Record<string, boolean>;
-}
-
-/** Load pal-settings.json from memory/ */
-function loadPalSettings(): PalSettings {
-  const p = resolve(paths.memory(), "pal-settings.json");
-  if (!existsSync(p)) return {};
-  try {
-    return JSON.parse(readFileSync(p, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-
-/** Check if a dynamic context section is enabled (defaults to true) */
-function isEnabled(settings: PalSettings, key: string): boolean {
-  return settings.dynamicContext?.[key] !== false;
-}
-
 /** Load and concatenate loadAtStartup files */
-function loadStartupFiles(settings: PalSettings): string {
-  const files = settings.loadAtStartup?.files;
-  if (!files || files.length === 0) return "";
+function loadStartupFiles(): string {
+  const files = settings.startupFiles();
+  if (files.length === 0) return "";
 
   const home = homedir();
   const sections: string[] = [];
@@ -223,6 +203,19 @@ export function loadLearningDigest(): string {
   }
 }
 
+/** Load self-model for session context injection */
+export function loadSelfModel(): string {
+  try {
+    const p = resolve(paths.memory(), "self-model", "current.md");
+    if (!existsSync(p)) return "";
+    const content = readFileSync(p, "utf-8").trim();
+    if (!content) return "";
+    return content;
+  } catch {
+    return "";
+  }
+}
+
 /** Load 5 most recent failure contexts as an "avoid" list */
 export function loadFailurePatterns(): string {
   try {
@@ -231,10 +224,11 @@ export function loadFailurePatterns(): string {
 
     const lines = entries.map((e) => {
       const label = e.rating ? `[${e.rating}/10]` : "";
-      return `- ${label} ${e.context}`.trim();
+      const text = e.principle || e.context;
+      return `- ${label} ${text}`.trim();
     });
 
-    return ["## Recent Failure Patterns (Avoid)", ...lines].join("\n");
+    return ["## Lessons from Recent Failures — Apply These Now", ...lines].join("\n");
   } catch {
     return "";
   }
@@ -451,30 +445,29 @@ export function loadHandoff(): string {
  * things that change per-session and can't live in a static file.
  */
 export function buildSystemReminder(): string {
-  const settings = loadPalSettings();
-  const startup = loadStartupFiles(settings);
-  const work = isEnabled(settings, "activeWork") ? loadActiveWork() : null;
-  const wisdom = isEnabled(settings, "wisdom") ? loadWisdomContext() : "";
-  const relationship = isEnabled(settings, "relationship")
+  const startup = loadStartupFiles();
+  const work = settings.isEnabled("activeWork") ? loadActiveWork() : null;
+  const wisdom = settings.isEnabled("wisdom") ? loadWisdomContext() : "";
+  const relationship = settings.isEnabled("relationship")
     ? loadRelationshipContext()
     : "";
-  const digest = isEnabled(settings, "learningDigest") ? loadLearningDigest() : "";
-  const projectHistory = isEnabled(settings, "projectHistory")
+  const digest = settings.isEnabled("learningDigest") ? loadLearningDigest() : "";
+  const projectHistory = settings.isEnabled("projectHistory")
     ? loadProjectHistoryContext()
     : "";
-  const trends = isEnabled(settings, "signalTrends") ? loadSignalTrends() : "";
-  const failures = isEnabled(settings, "failurePatterns") ? loadFailurePatterns() : "";
-  const synthesis = isEnabled(settings, "synthesis")
-    ? loadSynthesisRecommendations()
-    : "";
-  const opinions = isEnabled(settings, "opinions") ? loadOpinionContext() : "";
-  const intelligence = isEnabled(settings, "sessionIntelligence")
+  const trends = settings.isEnabled("signalTrends") ? loadSignalTrends() : "";
+  const failures = settings.isEnabled("failurePatterns") ? loadFailurePatterns() : "";
+  const synthesis = settings.isEnabled("synthesis") ? loadSynthesisRecommendations() : "";
+  const opinions = settings.isEnabled("opinions") ? loadOpinionContext() : "";
+  const selfModel = settings.isEnabled("selfModel") ? loadSelfModel() : "";
+  const intelligence = settings.isEnabled("sessionIntelligence")
     ? loadSessionIntelligence()
     : "";
-  const handoff = isEnabled(settings, "handoff") ? loadHandoff() : "";
+  const handoff = settings.isEnabled("handoff") ? loadHandoff() : "";
   const parts: string[] = [];
   if (startup) parts.push(startup);
   if (handoff) parts.push(handoff);
+  if (selfModel) parts.push(selfModel);
   if (wisdom) parts.push(wisdom);
   if (opinions) parts.push(opinions);
   if (intelligence) parts.push(intelligence);

package/src/hooks/lib/models.ts

@@ -3,6 +3,7 @@
  */
 
 export const HAIKU_MODEL = "claude-haiku-4-5-20251001";
+export const SONNET_MODEL = "claude-sonnet-4-6";
 
 /** Pricing per million tokens (USD) — from https://platform.claude.com/docs/en/about-claude/pricing */
 export const MODEL_PRICING: Record<

package/src/hooks/lib/settings.ts

@@ -0,0 +1,112 @@
+/**
+ * PalSettings — single source of truth for pal-settings.json.
+ *
+ * Reads once, caches in memory for the process lifetime.
+ * All consumers import from here instead of reading the file directly.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { paths } from "./paths";
+
+// ── Types ──
+
+export interface Identity {
+  ai: { name: string; fullName: string; displayName: string; catchphrase: string };
+  principal: { name: string; timezone: string };
+}
+
+export interface PalSettingsData {
+  identity?: {
+    ai?: { name?: string; fullName?: string; displayName?: string; catchphrase?: string };
+    principal?: { name?: string; timezone?: string };
+  };
+  loadAtStartup?: { files?: string[] };
+  dynamicContext?: Record<string, boolean>;
+  [key: string]: unknown;
+}
+
+const IDENTITY_DEFAULTS: Identity = {
+  ai: {
+    name: "Assistant",
+    fullName: "AI Assistant",
+    displayName: "ASSISTANT",
+    catchphrase: "",
+  },
+  principal: { name: "User", timezone: "" },
+};
+
+// ── Singleton ──
+
+let cached: PalSettingsData | null = null;
+
+function settingsPath(): string {
+  return resolve(paths.memory(), "pal-settings.json");
+}
+
+function load(): PalSettingsData {
+  if (cached) return cached;
+  const p = settingsPath();
+  if (!existsSync(p)) {
+    cached = {};
+    return cached;
+  }
+  try {
+    cached = JSON.parse(readFileSync(p, "utf-8")) as PalSettingsData;
+    return cached;
+  } catch {
+    cached = {};
+    return cached;
+  }
+}
+
+/** Force re-read from disk (useful after writes) */
+export function reload(): PalSettingsData {
+  cached = null;
+  return load();
+}
+
+// ── Public API ──
+
+/** Get the raw settings data */
+export function raw(): PalSettingsData {
+  return load();
+}
+
+/** Get resolved identity with defaults */
+export function identity(): Identity {
+  const data = load();
+  const ai = data.identity?.ai ?? {};
+  const principal = data.identity?.principal ?? {};
+  const name = ai.name || IDENTITY_DEFAULTS.ai.name;
+  const catchphrase = (ai.catchphrase || "").replace("{name}", name);
+
+  return {
+    ai: {
+      name,
+      fullName: ai.fullName || IDENTITY_DEFAULTS.ai.fullName,
+      displayName: ai.displayName || IDENTITY_DEFAULTS.ai.displayName,
+      catchphrase,
+    },
+    principal: {
+      name: principal.name || IDENTITY_DEFAULTS.principal.name,
+      timezone: principal.timezone || IDENTITY_DEFAULTS.principal.timezone,
+    },
+  };
+}
+
+/** Check if a dynamic context section is enabled (defaults to true) */
+export function isEnabled(key: string): boolean {
+  return load().dynamicContext?.[key] !== false;
+}
+
+/** Get the loadAtStartup file list */
+export function startupFiles(): string[] {
+  return load().loadAtStartup?.files ?? [];
+}
+
+/** Write settings back to disk and bust cache */
+export function write(data: PalSettingsData): void {
+  writeFileSync(settingsPath(), `${JSON.stringify(data, null, 2)}\n`, "utf-8");
+  cached = null;
+}

package/src/hooks/lib/stop.ts

@@ -8,11 +8,13 @@ import { resolve } from "node:path";
 import { autoBackup } from "../handlers/backup";
 import { captureFailure } from "../handlers/failure";
 import { checkReflectTrigger } from "../handlers/reflect-trigger";
+import { checkSelfModelTrigger } from "../handlers/self-model-trigger";
 import { captureSessionIntelligence } from "../handlers/session-intelligence";
 import { runSynthesis } from "../handlers/synthesis";
 import { resetTab } from "../handlers/tab";
 import { updateCounts } from "../handlers/update-counts";
 import { captureWorkSession } from "../handlers/work-session";
+import { inference } from "./inference";
 import { logDebug, logError } from "./log";
 import { ensureDir, paths } from "./paths";
 import { extractContent, extractLastAssistant, parseMessages } from "./transcript";
@@ -44,6 +46,7 @@ export async function runStopHandlers(
     updateCounts(),
     autoBackup(),
     checkReflectTrigger(),
+    checkSelfModelTrigger(),
     runSynthesis(),
   ]);
 
@@ -137,15 +140,63 @@ async function checkPendingFailure(transcript: string): Promise<void> {
       rating: number;
       context: string;
       detailedContext?: string;
+      principle?: string;
       responsePreview?: string;
       userPreview?: string;
     };
     unlinkSync(pendingPath);
+
+    // Extract principle from full transcript if not already present
+    let { principle, detailedContext } = pending;
+    if (!principle) {
+      try {
+        const msgs = parseMessages(transcript);
+        const recent = msgs
+          .slice(-10)
+          .map((m) => `${m.role.toUpperCase()}: ${extractContent(m).slice(0, 300)}`)
+          .join("\n\n");
+
+        const result = await inference({
+          system: `Analyze this failed AI interaction. The user rated it ${pending.rating}/10.
+
+Return JSON:
+{
+  "principle": "<one actionable rule the AI should follow, 10-20 words. Start with a verb: 'Verify...', 'Always...', 'Never...', 'Ask before...'>",
+  "detailed_context": "<what went wrong and why, 50-150 words>"
+}`,
+          user: `User feedback: ${pending.context}\n\nConversation:\n${recent}`,
+          maxTokens: 400,
+          timeout: 10000,
+          jsonSchema: {
+            type: "object" as const,
+            properties: {
+              principle: { type: "string" as const },
+              detailed_context: { type: "string" as const },
+            },
+            required: ["principle", "detailed_context"],
+            additionalProperties: false,
+          },
+        });
+
+        if (result.success && result.output) {
+          const parsed = JSON.parse(result.output) as {
+            principle?: string;
+            detailed_context?: string;
+          };
+          principle = parsed.principle || undefined;
+          if (!detailedContext) detailedContext = parsed.detailed_context || undefined;
+        }
+      } catch {
+        /* graceful fallback — capture without principle */
+      }
+    }
+
     await captureFailure(
       pending.rating,
       pending.context,
       transcript,
-      pending.detailedContext
+      detailedContext,
+      principle
     );
   } catch {
     // Non-critical

package/src/targets/lib.ts

@@ -660,21 +660,3 @@ export function countMd(dir: string): number {
     return 0;
   }
 }
-
-/** Read skill frontmatter field */
-export function readSkillField(skillPath: string, field: string): string {
-  try {
-    const content = readFileSync(skillPath, "utf-8");
-    const match = content.match(new RegExp(`^${field}:\\s*(.+)$`, "m"));
-    return match?.[1]?.trim() ?? "";
-  } catch {
-    return "";
-  }
-}
-
-/** Strip frontmatter from a skill file (content after second ---) */
-export function skillBody(skillPath: string): string {
-  const content = readFileSync(skillPath, "utf-8");
-  const parts = content.split(/^---\s*$/m);
-  return parts.length >= 3 ? parts.slice(2).join("---").trim() : content.trim();
-}