portable-agent-layer 0.63.3 → 0.65.0

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/hooks/lib/stop.ts

@@ -3,6 +3,7 @@
  * Used by StopOrchestrator.ts (Claude Code) and opencode plugin.
  */
 
+import { randomUUID } from "node:crypto";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { mkdtemp, rename, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
@@ -189,8 +190,10 @@ async function detachFailurePrinciple(transcript: string): Promise<void> {
   // Rename to claim the pending file atomically — prevents two Stop hooks
   // racing on the same low rating (opencode notably fires session.idle AND
   // session.diff concurrently, so runStopHandlers runs twice in parallel).
-  const claimedDir = await mkdtemp(resolve(tmpdir(), "pal-pending-"));
-  const claimedPath = resolve(claimedDir, "pending.json");
+  // The claim stays inside the state directory: rename fails with EXDEV across
+  // devices, and the OS temp dir is on another volume often enough to matter.
+  const claimId: string = randomUUID();
+  const claimedPath = resolve(paths.state(), `pending-failure.${claimId}.json`);
   try {
     await rename(pendingPath, claimedPath);
   } catch (err) {

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 ---
 
@@ -48,14 +50,20 @@ export function writeJson(path: string, data: unknown): void {
 /** Public PAL repository — the link surfaced in commit/PR co-author credits. */
 export const PAL_REPO_URL = "https://github.com/kovrichard/portable-agent-layer";
 
-/** Build the commit footer (bare URL, autolinks on GitHub) and PR body line (markdown link). */
+/**
+ * Build the commit footer (bare URL, autolinks on GitHub) and PR body line
+ * (markdown link). `sessionUrl` is off because Claude Code otherwise appends a
+ * claude.ai session link to commits made from web or Remote Control sessions,
+ * which puts a link to a private transcript in a public history.
+ */
 export function buildAttributionText(
   name: string,
   repoUrl: string = PAL_REPO_URL
-): { commit: string; pr: string } {
+): { commit: string; pr: string; sessionUrl: false } {
   return {
     commit: `Co-authored by ${name} · ${repoUrl}`,
     pr: `Co-authored by [${name}](${repoUrl})`,
+    sessionUrl: false,
   };
 }
 
@@ -73,7 +81,7 @@ export function applyAttribution(
     result.attribution = buildAttributionText(opts.name, opts.repoUrl);
     result.includeCoAuthoredBy = false;
   } else {
-    result.attribution = { commit: "", pr: "" };
+    result.attribution = { commit: "", pr: "", sessionUrl: false };
     if (result.includeCoAuthoredBy === false) delete result.includeCoAuthoredBy;
   }
   return result;
@@ -691,8 +699,8 @@ export function scaffoldPalSettings(): void {
 
 // --- PAL docs (modular context routing files) ---
 
-const PAL_DOCS_DIR = resolve(palHome(), "docs");
-const PAL_TOOLS_DIR = resolve(palHome(), "tools");
+const palDocsDir = () => resolve(palHome(), "docs");
+const palToolsDir = () => resolve(palHome(), "tools");
 
 /**
  * Install PAL system docs into ~/.pal/docs/.
@@ -703,19 +711,19 @@ export function copyPalDocs(): number {
   const srcDir = assets.palDocs();
   if (!existsSync(srcDir)) return 0;
 
-  mkdirSync(PAL_DOCS_DIR, { recursive: true });
+  mkdirSync(palDocsDir(), { recursive: true });
   let count = 0;
 
   for (const file of readdirSync(srcDir).filter((f) => f.endsWith(".md"))) {
     const src = resolve(srcDir, file);
-    const dst = resolve(PAL_DOCS_DIR, file);
+    const dst = resolve(palDocsDir(), file);
     copyFileSync(src, dst);
     count++;
   }
 
   // ~/.pal/tools/ → repo agent tools
   const linkType = process.platform === "win32" ? "junction" : "dir";
-  ensureSymlink(PAL_TOOLS_DIR, assets.agentTools(), linkType);
+  ensureSymlink(palToolsDir(), assets.agentTools(), linkType);
 
   return count;
 }
@@ -724,13 +732,13 @@ export function copyPalDocs(): number {
 export function removePalDocs(): void {
   // Remove tools symlink
   try {
-    unlinkSync(PAL_TOOLS_DIR);
+    unlinkSync(palToolsDir());
   } catch {
     /* gone */
   }
-  if (!existsSync(PAL_DOCS_DIR)) return;
+  if (!existsSync(palDocsDir())) return;
   try {
-    rmSync(PAL_DOCS_DIR, { recursive: true });
+    rmSync(palDocsDir(), { recursive: true });
     log.info("Removed ~/.pal/docs/");
   } catch {
     /* gone */
@@ -739,7 +747,7 @@ export function removePalDocs(): void {
 
 // --- Skills ---
 
-const PAL_SKILLS_DIR = resolve(palHome(), "skills");
+const palSkillsDir = () => resolve(palHome(), "skills");
 
 /**
  * Run one step of a bulk install, naming it only when it fails.
@@ -770,16 +778,20 @@ export function copySkills(claudeSkillsDir: string): number {
   const skillsDir = assets.skills();
   if (!existsSync(skillsDir)) return 0;
 
-  mkdirSync(PAL_SKILLS_DIR, { recursive: true });
+  mkdirSync(palSkillsDir(), { recursive: true });
   mkdirSync(claudeSkillsDir, { recursive: true });
   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;
 
-    const palLink = resolve(PAL_SKILLS_DIR, name);
+    const palLink = resolve(palSkillsDir(), name);
     const claudeLink = resolve(claudeSkillsDir, name);
     const linked = reportOnlyOnFailure(`skill ${name}`, () => {
       // ~/.pal/skills/<name> → <repo>/assets/skills/<name>
@@ -792,11 +804,60 @@ export function copySkills(claudeSkillsDir: string): number {
 
   // ~/.agents/skills/ → ~/.pal/skills/
   mkdirSync(platform.agentsDir(), { recursive: true });
-  ensureSymlink(resolve(platform.agentsDir(), "skills"), PAL_SKILLS_DIR, linkType);
+  ensureSymlink(resolve(platform.agentsDir(), "skills"), palSkillsDir(), linkType);
 
   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: palSkillsDir(), root: assets.skills() },
+    { dir: agentSkillsDir, root: palSkillsDir() },
+  ];
+  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.
  *
@@ -823,7 +884,7 @@ function perSkillAgentDirs(): { agent: string; dir: string }[] {
  * is covered by the whole-dir ~/.agents/skills link).
  */
 export function linkPersonalSkill(name: string): string[] {
-  const palLink = resolve(PAL_SKILLS_DIR, name);
+  const palLink = resolve(palSkillsDir(), name);
   if (!existsSync(resolve(palLink, "SKILL.md"))) {
     throw new Error(`No skill found at ${palLink}/SKILL.md`);
   }
@@ -837,8 +898,47 @@ export function linkPersonalSkill(name: string): string[] {
   return linked;
 }
 
+/**
+ * The agent config trees PAL writes into when no env override is set. These are
+ * the developer's own installed agents, so a test that forgets to point the
+ * PAL_*_DIR vars at a sandbox silently rewires their real setup.
+ */
+function realAgentRoots(): string[] {
+  const h = homedir();
+  return [
+    resolve(h, ".pal"),
+    resolve(h, ".claude"),
+    resolve(h, ".cursor"),
+    resolve(h, ".copilot"),
+    resolve(h, ".codex"),
+    resolve(h, ".agents"),
+    resolve(h, ".config", "opencode"),
+  ];
+}
+
+/**
+ * Under `bun test` (PAL_TEST_SANDBOX, set by the test preload and inherited by
+ * spawned CLIs), refuse any link that would land in a real agent tree. Tests
+ * sandbox PAL_HOME far more reliably than they sandbox the per-agent dirs, and
+ * the failure is otherwise invisible: the suite passes while the developer's
+ * own agents accumulate links into a deleted test directory.
+ */
+function assertInsideTestSandbox(link: string): void {
+  if (!process.env.PAL_TEST_SANDBOX) return;
+  const escaped = realAgentRoots().find(
+    (root) => link === root || link.startsWith(root + sep)
+  );
+  if (!escaped) return;
+  throw new Error(
+    `Refusing to write ${link}: outside the test sandbox (${escaped} is a real agent directory). ` +
+      "Point PAL_CLAUDE_DIR, PAL_CURSOR_DIR, PAL_COPILOT_DIR, PAL_CODEX_DIR, " +
+      "PAL_OPENCODE_DIR and PAL_AGENTS_DIR at a temp directory in this test."
+  );
+}
+
 /** Create or update a symlink/junction, replacing any non-symlink entry. */
 function ensureSymlink(link: string, target: string, type: "dir" | "junction"): void {
+  assertInsideTestSandbox(link);
   try {
     const st = lstatSync(link);
     if (st.isSymbolicLink()) return; // already a symlink, leave it
@@ -886,7 +986,7 @@ export function removeSkills(claudeSkillsDir: string): string[] {
   for (const name of readdirSync(skillsDir)) {
     if (!existsSync(resolve(skillsDir, name, "SKILL.md"))) continue;
 
-    for (const link of [resolve(PAL_SKILLS_DIR, name), resolve(claudeSkillsDir, name)]) {
+    for (const link of [resolve(palSkillsDir(), name), resolve(claudeSkillsDir, name)]) {
       try {
         unlinkSync(link);
       } catch {
@@ -909,14 +1009,14 @@ export function removeSkills(claudeSkillsDir: string): string[] {
 
 // --- Agents ---
 
-const CLAUDE_AGENTS_DIR = resolve(platform.claudeDir(), "agents");
+const claudeAgentsDir = () => resolve(platform.claudeDir(), "agents");
 
 /**
  * Install PAL agent definitions into ~/.claude/agents/.
  * Always overwrites — engine-managed, not user-editable.
  */
 export function copyAgents(): number {
-  return installAgents(CLAUDE_AGENTS_DIR, "claude");
+  return installAgents(claudeAgentsDir(), "claude");
 }
 
 /** Remove PAL agents from ~/.claude/agents/ */
@@ -926,7 +1026,7 @@ export function removeAgents(): string[] {
 
   const removed: string[] = [];
   for (const file of readdirSync(agentsDir).filter((f) => f.endsWith(".md"))) {
-    const dst = resolve(CLAUDE_AGENTS_DIR, file);
+    const dst = resolve(claudeAgentsDir(), file);
     if (existsSync(dst)) {
       unlinkSync(dst);
       const name = file.replace(/\.md$/, "");
@@ -939,9 +1039,9 @@ export function removeAgents(): string[] {
 
 /** Count agent .md files in ~/.claude/agents/ */
 export function countAgents(): number {
-  if (!existsSync(CLAUDE_AGENTS_DIR)) return 0;
+  if (!existsSync(claudeAgentsDir())) return 0;
   try {
-    return readdirSync(CLAUDE_AGENTS_DIR).filter((f) => f.endsWith(".md")).length;
+    return readdirSync(claudeAgentsDir()).filter((f) => f.endsWith(".md")).length;
   } catch {
     return 0;
   }
@@ -1077,7 +1177,7 @@ export function removeAgentsFromCopilot(copilotAgentsDir: string): string[] {
  * Store for user-authored subagents: ~/.pal/agents/<name>.md — one merged
  * multi-platform frontmatter file per subagent (same schema as assets/agents/).
  */
-const PAL_AGENTS_STORE = resolve(palHome(), "agents");
+const palAgentsStore = () => resolve(palHome(), "agents");
 
 /**
  * Each installed agent and the native agents directory a personal subagent is
@@ -1106,8 +1206,8 @@ function shippedAgentNames(): Set<string> {
 
 /** List the user-authored subagents in ~/.pal/agents/. */
 export function listPersonalSubagents(): string[] {
-  if (!existsSync(PAL_AGENTS_STORE)) return [];
-  return readdirSync(PAL_AGENTS_STORE)
+  if (!existsSync(palAgentsStore())) return [];
+  return readdirSync(palAgentsStore())
     .filter((f) => f.endsWith(".md"))
     .map((f) => f.replace(/\.md$/, ""))
     .sort();
@@ -1121,7 +1221,7 @@ export function listPersonalSubagents(): string[] {
  * its own frontmatter shape. Returns the agents it was installed into.
  */
 export function installPersonalSubagent(name: string): string[] {
-  const src = resolve(PAL_AGENTS_STORE, `${name}.md`);
+  const src = resolve(palAgentsStore(), `${name}.md`);
   if (!existsSync(src)) {
     throw new Error(`No subagent found at ${src}`);
   }
@@ -1319,7 +1419,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>();
@@ -1353,7 +1453,7 @@ function extractTriggers(description: string): string[] {
  * Called during install after skills are symlinked.
  */
 export function generateSkillIndex(): number {
-  if (!existsSync(PAL_SKILLS_DIR)) return 0;
+  if (!existsSync(palSkillsDir())) return 0;
 
   const index: SkillIndex = {
     generated: new Date().toISOString(),
@@ -1361,8 +1461,8 @@ export function generateSkillIndex(): number {
     skills: {},
   };
 
-  for (const name of readdirSync(PAL_SKILLS_DIR)) {
-    const skillMd = resolve(PAL_SKILLS_DIR, name, "SKILL.md");
+  for (const name of readdirSync(palSkillsDir())) {
+    const skillMd = resolve(palSkillsDir(), name, "SKILL.md");
     if (!existsSync(skillMd)) continue;
 
     try {
@@ -1378,10 +1478,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 {
@@ -1399,10 +1501,10 @@ export function generateSkillIndex(): number {
 
 /** Count skill subdirectories in ~/.pal/skills/ */
 export function countSkills(): number {
-  if (!existsSync(PAL_SKILLS_DIR)) return 0;
+  if (!existsSync(palSkillsDir())) return 0;
   try {
-    return readdirSync(PAL_SKILLS_DIR).filter((f) =>
-      existsSync(resolve(PAL_SKILLS_DIR, f, "SKILL.md"))
+    return readdirSync(palSkillsDir()).filter((f) =>
+      existsSync(resolve(palSkillsDir(), f, "SKILL.md"))
     ).length;
   } catch {
     return 0;

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([

package/src/tools/agent/algorithm-reflect.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env bun
+
 /**
  * AlgorithmReflect — Append structured algorithm reflections to JSONL.
  *
@@ -14,6 +15,8 @@
 
 import { appendFileSync } from "node:fs";
 import { parseArgs } from "node:util";
+import { encodeAnchor } from "../../hooks/lib/anchor";
+import { loadMachine } from "../../hooks/lib/machine";
 import { paths } from "../../hooks/lib/paths";
 import { emit } from "../lib/emit";
 
@@ -22,6 +25,7 @@ import { emit } from "../lib/emit";
 interface AlgorithmReflection {
   timestamp: string;
   cwd: string;
+  m: string;
   task: string;
   criteria_count: number;
   criteria_passed: number;
@@ -41,6 +45,40 @@ function reflectionsPath(): string {
   return paths.reflectionsFile();
 }
 
+/**
+ * Assemble a reflection record from CLI-style input, stamping the current
+ * cwd (anchored) and this machine's id. Exported so the stamping logic is
+ * directly testable without going through argv parsing.
+ */
+export function buildReflection(input: {
+  task: string;
+  q1: string;
+  q2: string;
+  q3: string;
+  criteria_count?: number;
+  criteria_passed?: number;
+  criteria_failed?: number;
+  sentiment?: number;
+  scope?: string;
+}): AlgorithmReflection {
+  return {
+    timestamp: new Date().toISOString(),
+    cwd: encodeAnchor(process.cwd()),
+    m: loadMachine().id,
+    task: input.task,
+    criteria_count: input.criteria_count ?? 0,
+    criteria_passed: input.criteria_passed ?? 0,
+    criteria_failed: input.criteria_failed ?? 0,
+    sentiment: Math.max(1, Math.min(10, input.sentiment ?? 5)),
+    q1: input.q1,
+    q2: input.q2,
+    q3: input.q3,
+    // Default to general (the ~94% case); only "task-specific" suppresses it
+    // from algorithm-update clustering.
+    scope: input.scope === "task-specific" ? "task-specific" : "general",
+  };
+}
+
 function appendReflection(reflection: AlgorithmReflection): {
   success: boolean;
   message: string;
@@ -105,21 +143,17 @@ Output: algorithm-reflections.jsonl in memory/learning/reflections/
     process.exit(1);
   }
 
-  const reflection: AlgorithmReflection = {
-    timestamp: new Date().toISOString(),
-    cwd: process.cwd(),
+  const reflection = buildReflection({
     task: values.task,
-    criteria_count: parseInt(values.criteria || "0", 10),
-    criteria_passed: parseInt(values.passed || "0", 10),
-    criteria_failed: parseInt(values.failed || "0", 10),
-    sentiment: Math.max(1, Math.min(10, parseInt(values.sentiment || "5", 10))),
     q1: values.q1,
     q2: values.q2,
     q3: values.q3,
-    // Default to general (the ~94% case); only "task-specific" suppresses it
-    // from algorithm-update clustering.
-    scope: values.scope === "task-specific" ? "task-specific" : "general",
-  };
+    criteria_count: parseInt(values.criteria || "0", 10),
+    criteria_passed: parseInt(values.passed || "0", 10),
+    criteria_failed: parseInt(values.failed || "0", 10),
+    sentiment: parseInt(values.sentiment || "5", 10),
+    scope: values.scope,
+  });
 
   const result = appendReflection(reflection);
   emit.ok(result.message);