selftune 0.2.8 → 0.2.10

package/cli/selftune/uninstall.ts

@@ -0,0 +1,412 @@
+#!/usr/bin/env bun
+/**
+ * selftune uninstall — Clean removal of all selftune data and configuration.
+ *
+ * Removes:
+ *   1. Autonomy scheduling (launchd/cron/systemd + OpenClaw cron)
+ *   2. Selftune hooks from ~/.claude/settings.json (surgical — preserves user hooks)
+ *   3. Selftune-managed Claude subagents from ~/.claude/agents/
+ *   4. JSONL telemetry logs from ~/.claude/
+ *   5. Selftune config directory (~/.selftune/)
+ *   6. Ingest marker files
+ *   7. Optionally: `npm uninstall -g selftune`
+ *
+ * Usage:
+ *   selftune uninstall [--dry-run] [--keep-logs] [--npm-uninstall]
+ */
+
+import { existsSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+
+import { removeInstalledAgentFiles } from "./claude-agents.js";
+import {
+  CLAUDE_CODE_MARKER,
+  CLAUDE_SETTINGS_PATH,
+  CODEX_INGEST_MARKER,
+  EVOLUTION_AUDIT_LOG,
+  EVOLUTION_EVIDENCE_LOG,
+  OPENCODE_INGEST_MARKER,
+  OPENCLAW_INGEST_MARKER,
+  ORCHESTRATE_LOCK,
+  ORCHESTRATE_RUN_LOG,
+  QUERY_LOG,
+  REPAIRED_SKILL_LOG,
+  REPAIRED_SKILL_SESSIONS_MARKER,
+  SELFTUNE_CONFIG_DIR,
+  SIGNAL_LOG,
+  SKILL_LOG,
+  TELEMETRY_LOG,
+  CANONICAL_LOG,
+} from "./constants.js";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+interface UninstallResult {
+  dryRun: boolean;
+  schedule: { removed: boolean; details: string };
+  hooks: { removed: number; details: string };
+  agents: { removed: number; files: string[] };
+  logs: { removed: number; skipped: boolean; files: string[] };
+  config: { removed: boolean; path: string };
+  markers: { removed: number; files: string[] };
+  npm: { uninstalled: boolean; skipped: boolean };
+}
+
+// ---------------------------------------------------------------------------
+// Step 1: Remove autonomy scheduling
+// ---------------------------------------------------------------------------
+
+async function removeScheduling(dryRun: boolean): Promise<{ removed: boolean; details: string }> {
+  // Try launchd first (macOS)
+  const label = "dev.selftune.orchestrate";
+  const plistPath = join(homedir(), "Library", "LaunchAgents", `${label}.plist`);
+
+  if (existsSync(plistPath)) {
+    if (dryRun) {
+      return { removed: false, details: `Would remove launchd plist: ${plistPath}` };
+    }
+    try {
+      // Unload before removing
+      Bun.spawnSync(["launchctl", "unload", plistPath], { stderr: "pipe" });
+      unlinkSync(plistPath);
+      return { removed: true, details: `Removed launchd plist: ${plistPath}` };
+    } catch (err) {
+      return {
+        removed: false,
+        details: `Failed to remove launchd plist: ${err instanceof Error ? err.message : String(err)}`,
+      };
+    }
+  }
+
+  // Try OpenClaw cron jobs
+  if (dryRun) {
+    return { removed: false, details: "Would remove cron jobs via selftune cron remove" };
+  }
+  try {
+    const proc = Bun.spawnSync(["selftune", "cron", "remove"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    if (proc.exitCode === 0) {
+      return { removed: true, details: "Removed cron jobs via selftune cron remove" };
+    }
+  } catch {
+    // selftune cron remove not available or failed — not critical
+  }
+
+  return { removed: false, details: "No scheduling artifacts found" };
+}
+
+// ---------------------------------------------------------------------------
+// Step 2: Remove selftune hooks from settings.json
+// ---------------------------------------------------------------------------
+
+/** Selftune hook scripts — used to identify which entries to remove. */
+const SELFTUNE_HOOK_SCRIPTS = [
+  "hooks/prompt-log.ts",
+  "hooks/auto-activate.ts",
+  "hooks/skill-change-guard.ts",
+  "hooks/evolution-guard.ts",
+  "hooks/skill-eval.ts",
+  "hooks/session-stop.ts",
+];
+
+function isSelfttuneHookEntry(entry: unknown): boolean {
+  if (typeof entry !== "object" || entry === null) return false;
+  const obj = entry as Record<string, unknown>;
+
+  // Check direct command
+  if (typeof obj.command === "string") {
+    return SELFTUNE_HOOK_SCRIPTS.some((script) => obj.command?.includes(script));
+  }
+
+  // Check hooks array (the nested structure used in settings.json)
+  if (Array.isArray(obj.hooks)) {
+    return obj.hooks.some(
+      (h: unknown) =>
+        typeof h === "object" &&
+        h !== null &&
+        typeof (h as Record<string, unknown>).command === "string" &&
+        SELFTUNE_HOOK_SCRIPTS.some((script) =>
+          ((h as Record<string, unknown>).command as string).includes(script),
+        ),
+    );
+  }
+
+  return false;
+}
+
+function removeHooksFromSettings(
+  dryRun: boolean,
+  settingsPath?: string,
+): { removed: number; details: string } {
+  const path = settingsPath ?? CLAUDE_SETTINGS_PATH;
+  if (!existsSync(path)) {
+    return { removed: 0, details: "No settings.json found" };
+  }
+
+  let settings: Record<string, unknown>;
+  try {
+    settings = JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return { removed: 0, details: "Failed to parse settings.json" };
+  }
+
+  const hooks = settings.hooks as Record<string, unknown[]> | undefined;
+  if (!hooks || typeof hooks !== "object") {
+    return { removed: 0, details: "No hooks section in settings.json" };
+  }
+
+  let totalRemoved = 0;
+
+  for (const key of Object.keys(hooks)) {
+    if (!Array.isArray(hooks[key])) continue;
+
+    const before = hooks[key].length;
+    hooks[key] = hooks[key].filter((entry) => !isSelfttuneHookEntry(entry));
+    const removed = before - hooks[key].length;
+    totalRemoved += removed;
+
+    // Clean up empty arrays
+    if (hooks[key].length === 0) {
+      delete hooks[key];
+    }
+  }
+
+  // Clean up empty hooks object
+  if (Object.keys(hooks).length === 0) {
+    delete settings.hooks;
+  }
+
+  if (totalRemoved > 0 && !dryRun) {
+    writeFileSync(path, JSON.stringify(settings, null, 2), "utf-8");
+  }
+
+  return {
+    removed: totalRemoved,
+    details: dryRun
+      ? `Would remove ${totalRemoved} selftune hook entries from ${path}`
+      : `Removed ${totalRemoved} selftune hook entries from ${path}`,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Step 3: Remove bundled Claude subagents
+// ---------------------------------------------------------------------------
+
+function removeAgents(dryRun: boolean): { removed: number; files: string[] } {
+  return removeInstalledAgentFiles({ dryRun });
+}
+
+// ---------------------------------------------------------------------------
+// Step 4: Remove JSONL log files
+// ---------------------------------------------------------------------------
+
+const LOG_FILES = [
+  TELEMETRY_LOG,
+  SKILL_LOG,
+  REPAIRED_SKILL_LOG,
+  CANONICAL_LOG,
+  QUERY_LOG,
+  EVOLUTION_AUDIT_LOG,
+  EVOLUTION_EVIDENCE_LOG,
+  ORCHESTRATE_RUN_LOG,
+  SIGNAL_LOG,
+  ORCHESTRATE_LOCK,
+];
+
+function removeLogs(dryRun: boolean): { removed: number; files: string[] } {
+  const removed: string[] = [];
+
+  for (const logPath of LOG_FILES) {
+    if (existsSync(logPath)) {
+      if (!dryRun) {
+        try {
+          unlinkSync(logPath);
+          removed.push(logPath);
+        } catch {
+          // Skip files we can't remove
+        }
+      } else {
+        removed.push(logPath);
+      }
+    }
+  }
+
+  return { removed: removed.length, files: removed };
+}
+
+// ---------------------------------------------------------------------------
+// Step 5: Remove config directory
+// ---------------------------------------------------------------------------
+
+function removeConfig(dryRun: boolean): { removed: boolean; path: string } {
+  if (!existsSync(SELFTUNE_CONFIG_DIR)) {
+    return { removed: false, path: SELFTUNE_CONFIG_DIR };
+  }
+
+  if (!dryRun) {
+    try {
+      rmSync(SELFTUNE_CONFIG_DIR, { recursive: true, force: true });
+      return { removed: true, path: SELFTUNE_CONFIG_DIR };
+    } catch {
+      return { removed: false, path: SELFTUNE_CONFIG_DIR };
+    }
+  }
+
+  return { removed: false, path: SELFTUNE_CONFIG_DIR };
+}
+
+// ---------------------------------------------------------------------------
+// Step 6: Remove ingest marker files
+// ---------------------------------------------------------------------------
+
+const MARKER_FILES = [
+  CLAUDE_CODE_MARKER,
+  CODEX_INGEST_MARKER,
+  OPENCODE_INGEST_MARKER,
+  OPENCLAW_INGEST_MARKER,
+  REPAIRED_SKILL_SESSIONS_MARKER,
+];
+
+function removeMarkers(dryRun: boolean): { removed: number; files: string[] } {
+  const removed: string[] = [];
+
+  for (const markerPath of MARKER_FILES) {
+    if (existsSync(markerPath)) {
+      if (!dryRun) {
+        try {
+          unlinkSync(markerPath);
+          removed.push(markerPath);
+        } catch {
+          // Skip files we can't remove
+        }
+      } else {
+        removed.push(markerPath);
+      }
+    }
+  }
+
+  return { removed: removed.length, files: removed };
+}
+
+// ---------------------------------------------------------------------------
+// Step 7: npm uninstall
+// ---------------------------------------------------------------------------
+
+async function npmUninstall(dryRun: boolean): Promise<{ uninstalled: boolean }> {
+  if (dryRun) {
+    return { uninstalled: false };
+  }
+
+  try {
+    const proc = Bun.spawnSync(["npm", "uninstall", "-g", "selftune"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    return { uninstalled: proc.exitCode === 0 };
+  } catch {
+    return { uninstalled: false };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main orchestrator
+// ---------------------------------------------------------------------------
+
+export interface UninstallOptions {
+  dryRun: boolean;
+  keepLogs: boolean;
+  npmUninstall: boolean;
+  settingsPath?: string;
+}
+
+export async function uninstall(options: UninstallOptions): Promise<UninstallResult> {
+  const { dryRun, keepLogs, settingsPath } = options;
+
+  // Step 1: Remove scheduling
+  const schedule = await removeScheduling(dryRun);
+
+  // Step 2: Remove hooks
+  const hooks = removeHooksFromSettings(dryRun, settingsPath);
+
+  // Step 3: Remove bundled Claude subagents
+  const agents = removeAgents(dryRun);
+
+  // Step 4: Remove logs
+  const logs = keepLogs
+    ? { removed: 0, skipped: true, files: [] }
+    : { ...removeLogs(dryRun), skipped: false };
+
+  // Step 5: Remove config directory
+  const config = removeConfig(dryRun);
+
+  // Step 6: Remove ingest markers
+  const markers = removeMarkers(dryRun);
+
+  // Step 7: npm uninstall (optional)
+  const npm = options.npmUninstall
+    ? { ...(await npmUninstall(dryRun)), skipped: false }
+    : { uninstalled: false, skipped: true };
+
+  return { dryRun, schedule, hooks, agents, logs, config, markers, npm };
+}
+
+// ---------------------------------------------------------------------------
+// CLI entry point
+// ---------------------------------------------------------------------------
+
+export async function cliMain(): Promise<void> {
+  const { values } = parseArgs({
+    options: {
+      "dry-run": { type: "boolean", default: false },
+      "keep-logs": { type: "boolean", default: false },
+      "npm-uninstall": { type: "boolean", default: false },
+      help: { type: "boolean", default: false },
+    },
+    strict: true,
+  });
+
+  if (values.help) {
+    console.log(`selftune uninstall — Clean removal of all selftune data and configuration
+
+Usage:
+  selftune uninstall [options]
+
+Options:
+  --dry-run        Preview what would be removed without deleting anything
+  --keep-logs      Preserve JSONL telemetry logs (remove everything else)
+  --npm-uninstall  Also run 'npm uninstall -g selftune'
+  --help           Show this help message
+
+Removes:
+  1. Autonomy scheduling (launchd/cron/systemd)
+  2. Selftune hooks from ~/.claude/settings.json (preserves user hooks)
+  3. Selftune-managed Claude subagents from ~/.claude/agents/
+  4. JSONL telemetry logs from ~/.claude/
+  5. Selftune config directory (~/.selftune/)
+  6. Ingest marker files
+  7. npm global package (with --npm-uninstall)`);
+    process.exit(0);
+  }
+
+  const result = await uninstall({
+    dryRun: values["dry-run"] ?? false,
+    keepLogs: values["keep-logs"] ?? false,
+    npmUninstall: values["npm-uninstall"] ?? false,
+  });
+
+  console.log(JSON.stringify(result, null, 2));
+  process.exit(0);
+}
+
+if (import.meta.main) {
+  cliMain().catch((err) => {
+    console.error(`[FATAL] ${err}`);
+    process.exit(1);
+  });
+}

package/cli/selftune/utils/canonical-log.ts

@@ -1,10 +1,12 @@
 import { existsSync, writeFileSync } from "node:fs";
+
 import {
   type CanonicalPlatform,
   type CanonicalRecord,
   type CanonicalRecordKind,
   isCanonicalRecord,
 } from "@selftune/telemetry-contract";
+
 import { CANONICAL_LOG } from "../constants.js";
 import { readJsonl } from "./jsonl.js";
 

package/cli/selftune/utils/jsonl.ts

@@ -14,6 +14,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { dirname } from "node:path";
+
 import { createLogger } from "./logging.js";
 import type { LogType } from "./schema-validator.js";
 import { validateRecord } from "./schema-validator.js";

package/cli/selftune/utils/llm-call.ts

@@ -123,6 +123,9 @@ function sleep(ms: number): Promise<void> {
 // Call LLM via agent subprocess
 // ---------------------------------------------------------------------------
 
+/** Effort level for Claude CLI (controls thinking depth). Opus 4.6 only for 'max'. */
+export type EffortLevel = "low" | "medium" | "high" | "max";
+
 /** Call LLM via agent subprocess (claude/codex/opencode). Returns raw text. */
 export async function callViaAgent(
   systemPrompt: string,
@@ -130,6 +133,7 @@ export async function callViaAgent(
   agent: string,
   modelFlag?: string,
   retryOpts?: RetryOptions,
+  effort?: EffortLevel,
 ): Promise<string> {
   // Write prompt to temp file to avoid shell quoting issues
   const promptFile = join(tmpdir(), `selftune-llm-${Date.now()}.txt`);
@@ -145,6 +149,9 @@ export async function callViaAgent(
         const resolved = resolveModelFlag(modelFlag);
         cmd.push("--model", resolved);
       }
+      if (effort) {
+        cmd.push("--effort", effort);
+      }
     } else if (agent === "codex") {
       cmd = ["codex", "exec", "--skip-git-repo-check", promptContent];
     } else if (agent === "opencode") {
@@ -173,9 +180,10 @@ export async function callViaAgent(
           env: { ...process.env, CLAUDECODE: "" },
         });
 
-        // Longer timeout for heavier models (sonnet/opus take longer than haiku)
+        // Longer timeout for heavier models and thinking effort levels
         const isLightModel = modelFlag === "haiku" || modelFlag?.includes("haiku");
-        const timeoutMs = isLightModel ? 120_000 : 300_000;
+        const isThinking = effort === "high" || effort === "max";
+        const timeoutMs = isThinking ? 600_000 : isLightModel ? 120_000 : 300_000;
         const timeout = setTimeout(() => proc.kill(), timeoutMs);
         const exitCode = await proc.exited;
         clearTimeout(timeout);
@@ -210,6 +218,125 @@ export async function callViaAgent(
   }
 }
 
+// ---------------------------------------------------------------------------
+// Call LLM via named subagent (multi-turn, agentic)
+// ---------------------------------------------------------------------------
+
+/** Options for calling a named Claude Code subagent. */
+export interface SubagentCallOptions {
+  /** Name of the subagent (synced into ~/.claude/agents/ by selftune init/update). */
+  agentName: string;
+  /** The task prompt for the subagent. */
+  prompt: string;
+  /** Optional system prompt appended to the agent's built-in instructions. */
+  appendSystemPrompt?: string;
+  /** Maximum agentic turns (default: 8). */
+  maxTurns?: number;
+  /** Model override (overrides the agent's frontmatter model). */
+  modelFlag?: string;
+  /** Effort level for thinking depth. */
+  effort?: EffortLevel;
+  /** Retry options. */
+  retryOpts?: RetryOptions;
+  /** Tools the agent is allowed to use without prompting. */
+  allowedTools?: string[];
+}
+
+/**
+ * Call a named Claude Code subagent in print mode. The subagent runs its
+ * multi-turn workflow (reading files, running commands, etc.) and returns
+ * the final text output.
+ *
+ * Unlike callViaAgent(), this does NOT use --bare (agents need discovery)
+ * and passes --agent + --max-turns for agentic multi-turn behavior.
+ * Only supports the claude CLI.
+ */
+export async function callViaSubagent(options: SubagentCallOptions): Promise<string> {
+  const {
+    agentName,
+    prompt,
+    appendSystemPrompt,
+    maxTurns = 8,
+    modelFlag,
+    effort,
+    retryOpts,
+    allowedTools,
+  } = options;
+
+  const cmd: string[] = [
+    "claude",
+    "-p",
+    prompt,
+    "--agent",
+    agentName,
+    "--max-turns",
+    String(maxTurns),
+  ];
+
+  if (appendSystemPrompt) {
+    cmd.push("--append-system-prompt", appendSystemPrompt);
+  }
+  if (modelFlag) {
+    const resolved = resolveModelFlag(modelFlag);
+    cmd.push("--model", resolved);
+  }
+  if (effort) {
+    cmd.push("--effort", effort);
+  }
+  if (allowedTools && allowedTools.length > 0) {
+    cmd.push("--allowedTools", ...allowedTools);
+  }
+  // Skip permissions since this runs non-interactively in a pipeline
+  cmd.push("--dangerously-skip-permissions");
+
+  const maxRetries = retryOpts?.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const initialBackoffMs = retryOpts?.initialBackoffMs ?? DEFAULT_INITIAL_BACKOFF_MS;
+  let lastError: Error | undefined;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    if (attempt > 0) {
+      const backoffMs = initialBackoffMs * 2 ** (attempt - 1);
+      logger.warn(
+        `Retry ${attempt}/${maxRetries} for subagent '${agentName}' after ${backoffMs}ms backoff`,
+      );
+      await sleep(backoffMs);
+    }
+
+    try {
+      const proc = Bun.spawn(cmd, {
+        stdout: "pipe",
+        stderr: "pipe",
+        env: { ...process.env, CLAUDECODE: "" },
+      });
+
+      // Subagents get a generous timeout — they do multi-turn work
+      const isThinking = effort === "high" || effort === "max";
+      const timeoutMs = isThinking ? 600_000 : 300_000;
+      const timeout = setTimeout(() => proc.kill(), timeoutMs);
+      const exitCode = await proc.exited;
+      clearTimeout(timeout);
+
+      if (exitCode !== 0) {
+        const stderr = await new Response(proc.stderr).text();
+        throw new Error(
+          `Subagent '${agentName}' exited with code ${exitCode}.\nstderr: ${stderr.slice(0, 500)}`,
+        );
+      }
+
+      const raw = await new Response(proc.stdout).text();
+      return raw;
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (!isTransientError(lastError) || attempt === maxRetries) {
+        throw lastError;
+      }
+      logger.warn(`Transient failure on attempt ${attempt + 1}: ${lastError.message}`);
+    }
+  }
+
+  throw lastError ?? new Error("callViaSubagent: unexpected retry loop exit");
+}
+
 // ---------------------------------------------------------------------------
 // Unified dispatcher
 // ---------------------------------------------------------------------------
@@ -220,9 +347,10 @@ export async function callLlm(
   userPrompt: string,
   agent: string,
   modelFlag?: string,
+  effort?: EffortLevel,
 ): Promise<string> {
   if (!agent) {
     throw new Error("Agent must be specified for callLlm");
   }
-  return callViaAgent(systemPrompt, userPrompt, agent, modelFlag);
+  return callViaAgent(systemPrompt, userPrompt, agent, modelFlag, undefined, effort);
 }

package/cli/selftune/utils/skill-log.ts

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
+
 import { REPAIRED_SKILL_LOG, REPAIRED_SKILL_SESSIONS_MARKER, SKILL_LOG } from "../constants.js";
 import type { SkillUsageRecord } from "../types.js";
 import { loadMarker, readJsonl, saveMarker } from "./jsonl.js";

package/cli/selftune/utils/transcript.ts

@@ -4,6 +4,7 @@
 
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname } from "node:path";
+
 import { CLAUDE_CODE_PROJECTS_DIR } from "../constants.js";
 import type { SessionTelemetryRecord, TranscriptMetrics } from "../types.js";
 import { isActionableQueryText } from "./query-filter.js";

package/cli/selftune/utils/trigger-check.ts

@@ -64,7 +64,7 @@ export function buildBatchTriggerCheckPrompt(description: string, queries: strin
  * original query order. Defaults to false for unparseable or missing lines.
  */
 export function parseBatchTriggerResponse(response: string, queryCount: number): boolean[] {
-  const results: boolean[] = new Array(queryCount).fill(false);
+  const results: boolean[] = Array.from({ length: queryCount }, () => false);
   const lines = response.trim().split("\n");
 
   for (const line of lines) {

package/cli/selftune/workflows/skill-md-writer.ts

@@ -36,7 +36,7 @@ export function parseWorkflowsSection(content: string): CodifiedWorkflow[] {
   // Find the end of the section (next ## heading or EOF)
   let sectionEnd = lines.length;
   for (let i = sectionStart; i < lines.length; i++) {
-    if (/^## /.test(lines[i]) && lines[i].trim() !== "## Workflows") {
+    if (lines[i].startsWith("## ") && lines[i].trim() !== "## Workflows") {
       sectionEnd = i;
       break;
     }
@@ -155,7 +155,7 @@ export function appendWorkflow(content: string, workflow: CodifiedWorkflow): str
     // Find the end of the workflows section (next ## heading or EOF)
     let sectionEnd = lines.length;
     for (let i = sectionStart + 1; i < lines.length; i++) {
-      if (/^## /.test(lines[i])) {
+      if (lines[i].startsWith("## ")) {
         sectionEnd = i;
         break;
       }
@@ -210,7 +210,7 @@ export function removeWorkflow(content: string, name: string): string {
   // Find the end of the workflows section
   let sectionEnd = lines.length;
   for (let i = sectionStart + 1; i < lines.length; i++) {
-    if (/^## /.test(lines[i])) {
+    if (lines[i].startsWith("## ")) {
       sectionEnd = i;
       break;
     }
@@ -226,7 +226,7 @@ export function removeWorkflow(content: string, name: string): string {
       // Find the end of this subsection (next ### or ## or sectionEnd)
       subEnd = sectionEnd;
       for (let j = i + 1; j < sectionEnd; j++) {
-        if (/^### /.test(lines[j])) {
+        if (lines[j].startsWith("### ")) {
           subEnd = j;
           break;
         }
@@ -255,7 +255,7 @@ export function removeWorkflow(content: string, name: string): string {
 
   // Check if the workflows section is now empty
   const remaining = [...before.slice(sectionStart + 1), ...after.slice(0, sectionEnd - removeTo)];
-  const hasRemainingWorkflows = remaining.some((l) => /^### /.test(l));
+  const hasRemainingWorkflows = remaining.some((l) => l.startsWith("### "));
 
   if (!hasRemainingWorkflows) {
     // Remove the entire ## Workflows section (heading + any blank lines)

package/cli/selftune/workflows/workflows.ts

@@ -10,6 +10,7 @@
 
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { parseArgs } from "node:util";
+
 import { getDb } from "../localdb/db.js";
 import { querySessionTelemetry, querySkillUsageRecords } from "../localdb/queries.js";
 import type {