selftune 0.2.14 → 0.2.16

package/cli/selftune/ingestors/claude-replay.ts

@@ -55,6 +55,7 @@ import type {
   SessionTelemetryRecord,
   TranscriptMetrics,
 } from "../types.js";
+import { CLIError, handleCLIError } from "../utils/cli-error.js";
 import { loadMarker, saveMarker } from "../utils/jsonl.js";
 import { isActionableQueryText } from "../utils/query-filter.js";
 import {
@@ -326,26 +327,36 @@ export function buildCanonicalRecordsFromReplay(session: ParsedSession): Canonic
 
 // --- CLI main ---
 export function cliMain(): void {
-  const { values } = parseArgs({
-    options: {
-      "projects-dir": { type: "string", default: CLAUDE_CODE_PROJECTS_DIR },
-      since: { type: "string" },
-      "dry-run": { type: "boolean", default: false },
-      force: { type: "boolean", default: false },
-      verbose: { type: "boolean", short: "v", default: false },
-    },
-    strict: true,
-  });
+  let values: Record<string, string | boolean | undefined>;
+  try {
+    ({ values } = parseArgs({
+      options: {
+        "projects-dir": { type: "string", default: CLAUDE_CODE_PROJECTS_DIR },
+        since: { type: "string" },
+        "dry-run": { type: "boolean", default: false },
+        force: { type: "boolean", default: false },
+        verbose: { type: "boolean", short: "v", default: false },
+      },
+      strict: true,
+    }));
+  } catch (err) {
+    throw new CLIError(
+      err instanceof Error ? err.message : String(err),
+      "INVALID_FLAG",
+      "selftune ingest claude --since 2026-01-01",
+    );
+  }
 
   const projectsDir = values["projects-dir"] ?? CLAUDE_CODE_PROJECTS_DIR;
   let since: Date | undefined;
   if (values.since) {
     since = new Date(values.since);
     if (Number.isNaN(since.getTime())) {
-      console.error(
-        `Error: Invalid --since date: "${values.since}". Use a valid date format (e.g., 2026-01-01).`,
+      throw new CLIError(
+        `Invalid --since date: "${values.since}"`,
+        "INVALID_FLAG",
+        "selftune ingest claude --since 2026-01-01",
       );
-      process.exit(1);
     }
   }
 
@@ -401,5 +412,9 @@ export function cliMain(): void {
 }
 
 if (import.meta.main) {
-  cliMain();
+  try {
+    cliMain();
+  } catch (err) {
+    handleCLIError(err);
+  }
 }

package/cli/selftune/ingestors/codex-rollout.ts

@@ -49,6 +49,7 @@ import type {
   SessionTelemetryRecord,
   SkillUsageRecord,
 } from "../types.js";
+import { handleCLIError } from "../utils/cli-error.js";
 import { loadMarker, saveMarker } from "../utils/jsonl.js";
 import { extractActionableQueryText } from "../utils/query-filter.js";
 import {
@@ -717,5 +718,9 @@ export function cliMain(): void {
 }
 
 if (import.meta.main) {
-  cliMain();
+  try {
+    cliMain();
+  } catch (err) {
+    handleCLIError(err);
+  }
 }

package/cli/selftune/init.ts

@@ -44,7 +44,8 @@ import {
 import { installAgentFiles } from "./claude-agents.js";
 import { CLAUDE_CODE_HOOK_KEYS, SELFTUNE_CONFIG_DIR, SELFTUNE_CONFIG_PATH } from "./constants.js";
 import type { AgentCommandGuidance, AlphaIdentity, SelftuneConfig } from "./types.js";
-import { hookKeyHasSelftuneEntry } from "./utils/hooks.js";
+import { CLIError, handleCLIError } from "./utils/cli-error.js";
+import { hookKeyHasSelftuneEntry, isSelftuneCommand } from "./utils/hooks.js";
 import { detectAgent } from "./utils/llm-call.js";
 
 export { installAgentFiles } from "./claude-agents.js";
@@ -228,10 +229,13 @@ const SETTINGS_SNIPPET_PATH = resolve(
  *
  * - Creates settings.json if it does not exist
  * - Creates the hooks section if it does not exist
- * - Only adds hook entries for keys that don't already have a selftune entry
- * - Never overwrites existing user hooks
+ * - Adds hook entries for keys that don't already have a selftune entry
+ * - Updates existing selftune entries with new attributes from the snippet
+ *   (e.g. `if`, `statusMessage`, `async`, `timeout`) while preserving
+ *   the resolved `command` path from the existing entry
+ * - Never overwrites existing non-selftune hooks
  *
- * Returns the list of hook keys that were added.
+ * Returns the list of hook keys that were added or updated.
  */
 export function installClaudeCodeHooks(options?: {
   settingsPath?: string;
@@ -278,43 +282,211 @@ export function installClaudeCodeHooks(options?: {
   }
   const existingHooks = settings.hooks as Record<string, unknown[]>;
 
-  // Resolve the CLI hooks directory for path substitution
+  // Resolve the package root for path substitution
+  // cliPath points to cli/selftune/index.ts → package root is two levels up
   const cliPath = options?.cliPath;
-  const hooksDir = cliPath ? `${dirname(cliPath)}/hooks` : null;
+  const packageRoot = cliPath ? resolve(dirname(cliPath), "..", "..").replace(/\\/g, "/") : null;
 
-  const addedKeys: string[] = [];
+  const changedKeys: string[] = [];
 
   for (const key of Object.keys(snippetHooks)) {
-    // Skip if this key already has a selftune entry
-    if (hookKeyHasSelftuneEntry(existingHooks, key)) {
-      continue;
-    }
-
-    // Get the snippet entries for this key, replacing /PATH/TO/ with actual path
+    // Get the snippet entries for this key, replacing /PATH/TO/ with actual package root
     let entries = snippetHooks[key];
-    if (hooksDir) {
-      // Deep clone and substitute paths
-      const raw = JSON.stringify(entries).replace(/\/PATH\/TO\/cli\/selftune\/hooks/g, hooksDir);
+    if (packageRoot) {
+      // Deep clone and substitute all /PATH/TO/ references with the resolved package root
+      const raw = JSON.stringify(entries).replace(/\/PATH\/TO\//g, `${packageRoot}/`);
       entries = JSON.parse(raw);
     }
 
-    // Merge: append to existing array or create new one
-    if (Array.isArray(existingHooks[key])) {
-      existingHooks[key] = [...existingHooks[key], ...entries];
+    if (hookKeyHasSelftuneEntry(existingHooks, key)) {
+      // Key already has selftune hooks — update them in-place with new attributes
+      // while preserving non-selftune entries and the resolved command paths
+      if (updateExistingSelftuneHooks(existingHooks, key, entries)) {
+        changedKeys.push(key);
+      }
     } else {
-      existingHooks[key] = entries;
+      // No selftune entry yet — add the snippet entries
+      if (Array.isArray(existingHooks[key])) {
+        existingHooks[key] = [...existingHooks[key], ...entries];
+      } else {
+        existingHooks[key] = entries;
+      }
+      changedKeys.push(key);
     }
-
-    addedKeys.push(key);
   }
 
-  if (addedKeys.length > 0) {
+  if (changedKeys.length > 0) {
     // Ensure ~/.claude/ directory exists
     mkdirSync(dirname(settingsPath), { recursive: true });
     writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
   }
 
-  return addedKeys;
+  return changedKeys;
+}
+
+/**
+ * Update existing selftune hook entries in-place with new attributes from the snippet.
+ *
+ * For each matcher group that contains selftune hooks, replaces ALL selftune
+ * hook entries with the full set of snippet entries while:
+ *   - Resolving snippet commands using the package root from existing entries
+ *   - Preserving non-selftune hooks in the same matcher group
+ *   - Handling N→M changes (e.g. 2 hooks expanding to 4 with Write/Edit splits)
+ *
+ * Returns true if any entries were actually modified.
+ */
+export function updateExistingSelftuneHooks(
+  existingHooks: Record<string, unknown[]>,
+  key: string,
+  snippetEntries: unknown[],
+): boolean {
+  const existingArray = existingHooks[key];
+  if (!Array.isArray(existingArray)) return false;
+
+  // Collect all snippet hooks (flattened from matcher groups)
+  const allSnippetHooks: Array<Record<string, unknown>> = [];
+  for (const group of snippetEntries) {
+    if (typeof group !== "object" || group === null) continue;
+    const g = group as Record<string, unknown>;
+    const hooks = g.hooks as Array<Record<string, unknown>> | undefined;
+    if (!Array.isArray(hooks)) continue;
+    allSnippetHooks.push(...hooks);
+  }
+
+  if (allSnippetHooks.length === 0) return false;
+
+  let modified = false;
+
+  for (let i = 0; i < existingArray.length; i++) {
+    const group = existingArray[i];
+    if (typeof group !== "object" || group === null) continue;
+    const g = group as Record<string, unknown>;
+    const hooks = g.hooks as Array<Record<string, unknown>> | undefined;
+
+    // Handle flat entries (direct { command: "..." } without nested hooks array).
+    // These are a legacy format from older selftune versions or manual installs.
+    if (!Array.isArray(hooks)) {
+      if (!isHookSelftune(g)) continue;
+      const pkgRoot = derivePackageRootFromCommand(typeof g.command === "string" ? g.command : "");
+
+      // Replace the flat entry with the full snippet group structure.
+      // If we can derive a package root, resolve /PATH/TO/ in the snippet.
+      // If not (e.g. "npx selftune hook ..."), use snippet entries as-is
+      // (they were already resolved by the caller if a cliPath was provided).
+      const resolvedEntries = snippetEntries.map((se) => {
+        if (!pkgRoot) return se;
+        const raw = JSON.stringify(se).replace(/\/PATH\/TO\//g, `${pkgRoot}/`);
+        return JSON.parse(raw);
+      });
+      existingArray.splice(i, 1, ...resolvedEntries);
+      modified = true;
+      continue;
+    }
+
+    // Derive package root from the first selftune hook in this group
+    let packageRoot: string | null = null;
+    for (const hook of hooks) {
+      if (isHookSelftune(hook)) {
+        packageRoot = derivePackageRootFromCommand(
+          typeof hook.command === "string" ? hook.command : "",
+        );
+        if (packageRoot) break;
+      }
+    }
+
+    // Check if this group has any selftune hooks at all
+    const hasSelftuneHooks = hooks.some(isHookSelftune);
+    if (!hasSelftuneHooks) continue;
+
+    // Build resolved snippet hooks using the derived package root.
+    // If no package root was derivable (e.g. "npx selftune hook ..."),
+    // use snippet hooks as-is (already resolved by caller if cliPath was provided).
+    const resolvedSnippetHooks = allSnippetHooks.map((snippetHook) => {
+      const cmd = typeof snippetHook.command === "string" ? snippetHook.command : "";
+      const resolvedCmd = packageRoot ? cmd.replace(/\/PATH\/TO\//g, `${packageRoot}/`) : cmd;
+      return { ...snippetHook, command: resolvedCmd };
+    });
+
+    // Check if anything actually changed (compare sorted JSON for order independence)
+    const oldSelftune = hooks.filter(isHookSelftune);
+    const oldSorted = JSON.stringify(sortKeys(oldSelftune));
+    const newSorted = JSON.stringify(sortKeys(resolvedSnippetHooks));
+    if (oldSorted !== newSorted) {
+      modified = true;
+    }
+
+    // Rebuild hooks preserving original ordering of non-selftune entries:
+    // replace the first selftune hook with all resolved snippet hooks,
+    // remove remaining old selftune hooks, keep non-selftune hooks in place
+    const updatedHooks: Array<Record<string, unknown>> = [];
+    let selftuneInserted = false;
+    for (const hook of hooks) {
+      if (isHookSelftune(hook)) {
+        if (!selftuneInserted) {
+          // Insert all resolved snippet hooks at the position of the first selftune hook
+          updatedHooks.push(...resolvedSnippetHooks);
+          selftuneInserted = true;
+        }
+        // Skip remaining old selftune hooks (replaced by snippet set above)
+      } else {
+        updatedHooks.push(hook);
+      }
+    }
+    g.hooks = updatedHooks;
+  }
+
+  return modified;
+}
+
+/** Check if a hook entry is a selftune-managed hook. Delegates to shared isSelftuneCommand. */
+function isHookSelftune(hook: Record<string, unknown>): boolean {
+  return typeof hook.command === "string" && isSelftuneCommand(hook.command);
+}
+
+/** Sort object keys recursively for order-independent JSON comparison. */
+function sortKeys(obj: unknown): unknown {
+  if (Array.isArray(obj)) return obj.map(sortKeys);
+  if (obj !== null && typeof obj === "object") {
+    const sorted: Record<string, unknown> = {};
+    for (const key of Object.keys(obj as Record<string, unknown>).sort()) {
+      sorted[key] = sortKeys((obj as Record<string, unknown>)[key]);
+    }
+    return sorted;
+  }
+  return obj;
+}
+
+/**
+ * Derive the selftune package root from an existing hook command.
+ * Supports both old format ("bun run .../cli/selftune/hooks/X.ts")
+ * and new format ("node .../bin/run-hook.cjs .../cli/selftune/hooks/X.ts").
+ *
+ * Handles paths with spaces (e.g. "/Users/Alice Smith/...") and
+ * optional surrounding quotes in the command string.
+ */
+export function derivePackageRootFromCommand(command: string): string | null {
+  // Normalize: strip quotes, collapse backslashes (for Windows-style paths)
+  const normalized = command.replace(/["']/g, "").replace(/\\/g, "/");
+  // Split on the known directory marker and take the prefix.
+  // The command may contain the package root multiple times (e.g.
+  // "node /root/bin/run-hook.cjs /root/cli/selftune/hooks/script.ts")
+  // so we split on the LAST occurrence of the marker.
+  for (const marker of ["/cli/selftune/hooks/", "/bin/run-hook.cjs"]) {
+    const idx = normalized.lastIndexOf(marker);
+    if (idx === -1) continue;
+    // Everything before the marker is "<prefix> <package-root>" or just "<package-root>"
+    const beforeMarker = normalized.slice(0, idx);
+    // Find the start of the path: scan backwards from end for the path start.
+    // Paths start with / (Unix) or a drive letter like C:/ (Windows).
+    // The command prefix (e.g. "node " or "bun run ") precedes the path.
+    const pathMatch = beforeMarker.match(/.*\s(\/.*|[A-Za-z]:\/.*)/);
+    if (pathMatch) return pathMatch[1];
+    // No space prefix — the entire string is the path (e.g. no "node " prefix)
+    if (beforeMarker.startsWith("/") || /^[A-Za-z]:\//.test(beforeMarker)) {
+      return beforeMarker;
+    }
+  }
+  return null;
 }
 
 // ---------------------------------------------------------------------------
@@ -614,16 +786,16 @@ export async function runInit(opts: InitOptions): Promise<SelftuneConfig> {
       );
     }
 
-    const addedHookKeys = installClaudeCodeHooks({
+    const changedHookKeys = installClaudeCodeHooks({
       settingsPath,
       cliPath,
     });
-    if (addedHookKeys.length > 0) {
+    if (changedHookKeys.length > 0) {
       config.hooks_installed = true;
       // Re-write config with updated hooks_installed flag
       writeSelftuneConfig(configPath, config);
       console.error(
-        `[INFO] Installed ${addedHookKeys.length} selftune hook(s) into ${settingsPath}: ${addedHookKeys.join(", ")}`,
+        `[INFO] Installed/updated ${changedHookKeys.length} selftune hook(s) in ${settingsPath}: ${changedHookKeys.join(", ")}`,
       );
     } else if (!config.hooks_installed) {
       // Re-check in case hooks were already present
@@ -692,8 +864,11 @@ export async function cliMain(): Promise<void> {
   try {
     validateAlphaMetadataFlags(values.alpha, values["alpha-email"], values["alpha-name"]);
   } catch (error) {
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exit(1);
+    throw new CLIError(
+      error instanceof Error ? error.message : String(error),
+      "INVALID_FLAG",
+      "Pass --alpha along with --alpha-email and --alpha-name.",
+    );
   }
 
   // Check for existing config without force
@@ -890,10 +1065,11 @@ export async function cliMain(): Promise<void> {
       });
 
       if (!scheduleResult.activated) {
-        console.error(
-          "Failed to activate the autonomous scheduler. Re-run with --schedule-format or use `selftune schedule --install --dry-run` to inspect the generated artifacts first.",
+        throw new CLIError(
+          "Failed to activate the autonomous scheduler.",
+          "OPERATION_FAILED",
+          "Re-run with --schedule-format or use `selftune schedule --install --dry-run` to inspect the generated artifacts first.",
         );
-        process.exit(1);
       }
 
       console.log(
@@ -906,10 +1082,11 @@ export async function cliMain(): Promise<void> {
         }),
       );
     } catch (err) {
-      console.error(
+      throw new CLIError(
         `Failed to enable autonomy: ${err instanceof Error ? err.message : String(err)}`,
+        "OPERATION_FAILED",
+        "Re-run with --schedule-format or use `selftune schedule --install --dry-run` to inspect artifacts.",
       );
-      process.exit(1);
     }
   }
 }
@@ -947,7 +1124,6 @@ if (isMain) {
       console.error(JSON.stringify(err.payload));
       process.exit(1);
     }
-    console.error(`[FATAL] ${err}`);
-    process.exit(1);
+    handleCLIError(err);
   });
 }

package/cli/selftune/monitoring/watch.ts

@@ -26,6 +26,7 @@ import type {
   SessionTelemetryRecord,
   SkillUsageRecord,
 } from "../types.js";
+import { CLIError, handleCLIError } from "../utils/cli-error.js";
 import {
   filterActionableQueryRecords,
   filterActionableSkillUsageRecords,
@@ -354,34 +355,52 @@ Options:
   }
 
   if (!values.skill || !values["skill-path"]) {
-    console.error("[ERROR] --skill and --skill-path are required");
-    process.exit(1);
+    throw new CLIError(
+      "--skill and --skill-path are required.",
+      "MISSING_FLAG",
+      "Usage: selftune watch --skill <name> --skill-path <path>",
+    );
   }
   if ((values["sync-force"] ?? false) && !(values["sync-first"] ?? false)) {
-    console.error("[ERROR] --sync-force requires --sync-first");
-    process.exit(1);
+    throw new CLIError(
+      "--sync-force requires --sync-first.",
+      "INVALID_FLAG",
+      "Add --sync-first when using --sync-force.",
+    );
   }
 
   const rawWindow = values.window ?? "20";
   if (!/^\d+$/.test(rawWindow)) {
-    console.error("[ERROR] --window must be a positive integer >= 1");
-    process.exit(1);
+    throw new CLIError(
+      "--window must be a positive integer >= 1.",
+      "INVALID_FLAG",
+      "selftune watch --window 20",
+    );
   }
   const windowSessions = Number.parseInt(rawWindow, 10);
   if (windowSessions < 1) {
-    console.error("[ERROR] --window must be a positive integer >= 1");
-    process.exit(1);
+    throw new CLIError(
+      "--window must be a positive integer >= 1.",
+      "INVALID_FLAG",
+      "selftune watch --window 20",
+    );
   }
 
   const rawThreshold = values.threshold ?? "0.1";
   if (!/^\d+(\.\d+)?$/.test(rawThreshold)) {
-    console.error("[ERROR] --threshold must be a finite number between 0 and 1");
-    process.exit(1);
+    throw new CLIError(
+      "--threshold must be a finite number between 0 and 1.",
+      "INVALID_FLAG",
+      "selftune watch --threshold 0.1",
+    );
   }
   const regressionThreshold = Number.parseFloat(rawThreshold);
   if (regressionThreshold < 0 || regressionThreshold > 1) {
-    console.error("[ERROR] --threshold must be a finite number between 0 and 1");
-    process.exit(1);
+    throw new CLIError(
+      "--threshold must be a finite number between 0 and 1.",
+      "INVALID_FLAG",
+      "selftune watch --threshold 0.1",
+    );
   }
 
   const result = await watch({
@@ -399,8 +418,5 @@ Options:
 }
 
 if (import.meta.main) {
-  cliMain().catch((err) => {
-    console.error(`[FATAL] ${err}`);
-    process.exit(1);
-  });
+  cliMain().catch(handleCLIError);
 }

package/cli/selftune/orchestrate.ts

@@ -53,6 +53,7 @@ import type {
   SessionTelemetryRecord,
   SkillUsageRecord,
 } from "./types.js";
+import { CLIError, handleCLIError } from "./utils/cli-error.js";
 import { detectAgent } from "./utils/llm-call.js";
 import { getSelftuneVersion, readConfiguredAgentType } from "./utils/selftune-meta.js";
 import {
@@ -1249,37 +1250,41 @@ Examples:
 
   const maxSkillsRaw = values["max-skills"] ?? "5";
   if (!/^\d+$/.test(maxSkillsRaw) || Number(maxSkillsRaw) < 1) {
-    console.error(
-      "[ERROR] --max-skills must be a positive integer. Retry with: selftune orchestrate --max-skills 5",
+    throw new CLIError(
+      "--max-skills must be a positive integer",
+      "INVALID_FLAG",
+      "selftune orchestrate --max-skills 5",
     );
-    process.exit(1);
   }
   const maxSkills = Number(maxSkillsRaw);
 
   const recentWindowRaw = values["recent-window"] ?? "48";
   if (!/^\d+$/.test(recentWindowRaw) || Number(recentWindowRaw) < 1) {
-    console.error(
-      "[ERROR] --recent-window must be a positive integer. Retry with: selftune orchestrate --recent-window 48",
+    throw new CLIError(
+      "--recent-window must be a positive integer",
+      "INVALID_FLAG",
+      "selftune orchestrate --recent-window 48",
     );
-    process.exit(1);
   }
   const recentWindow = Number(recentWindowRaw);
 
   const maxAutoGradeRaw = values["max-auto-grade"] ?? "5";
   if (!/^\d+$/.test(maxAutoGradeRaw)) {
-    console.error(
-      "[ERROR] --max-auto-grade must be a non-negative integer. Retry with: selftune orchestrate --max-auto-grade 5",
+    throw new CLIError(
+      "--max-auto-grade must be a non-negative integer",
+      "INVALID_FLAG",
+      "selftune orchestrate --max-auto-grade 5",
     );
-    process.exit(1);
   }
   const maxAutoGrade = Number(maxAutoGradeRaw);
 
   const loopIntervalRaw = values["loop-interval"] ?? "3600";
   if (!/^\d+$/.test(loopIntervalRaw) || (values.loop && Number(loopIntervalRaw) < 60)) {
-    console.error(
-      "[ERROR] --loop-interval must be an integer >= 60 (seconds). Retry with: selftune orchestrate --loop --loop-interval 3600",
+    throw new CLIError(
+      "--loop-interval must be an integer >= 60 (seconds)",
+      "INVALID_FLAG",
+      "selftune orchestrate --loop --loop-interval 3600",
     );
-    process.exit(1);
   }
   const loopInterval = Number(loopIntervalRaw);
 
@@ -1387,9 +1392,5 @@ Examples:
 }
 
 if (import.meta.main) {
-  cliMain().catch((err) => {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`[FATAL] ${message}`);
-    process.exit(1);
-  });
+  cliMain().catch(handleCLIError);
 }

package/cli/selftune/routes/skill-report.ts

@@ -8,6 +8,7 @@
 
 import type { Database } from "bun:sqlite";
 
+import { scoreDescription } from "../evolution/description-quality.js";
 import { getPendingProposals, getSkillReportPayload, safeParseJson } from "../localdb/queries.js";
 
 export function handleSkillReport(db: Database, skillName: string): Response {
@@ -203,6 +204,21 @@ export function handleSkillReport(db: Database, skillName: string): Response {
     completion_status: string | null;
   }>;
 
+  // 8. Description quality score — computed from latest evolution evidence
+  const latestEvidence = db
+    .query(
+      `SELECT proposed_text, original_text FROM evolution_evidence
+       WHERE skill_name = ? AND (proposed_text IS NOT NULL OR original_text IS NOT NULL)
+       ORDER BY timestamp DESC LIMIT 1`,
+    )
+    .get(skillName) as { proposed_text: string | null; original_text: string | null } | null;
+
+  // Use the most recent description: deployed proposed_text, or fallback to original_text
+  const currentDescriptionText = latestEvidence?.proposed_text ?? latestEvidence?.original_text;
+  const descriptionQuality = currentDescriptionText
+    ? scoreDescription(currentDescriptionText, skillName)
+    : null;
+
   return Response.json({
     ...report,
     evolution: evolutionWithSnapshot,
@@ -227,5 +243,6 @@ export function handleSkillReport(db: Database, skillName: string): Response {
       is_actionable: p.is_actionable === 1,
     })),
     session_metadata: sessionMeta,
+    description_quality: descriptionQuality,
   });
 }