@iowarp/clio-coder 0.3.9 → 0.4.1

package/dist/chunk-QTFGO774.js

@@ -0,0 +1,644 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  ensureYaziProfile,
+  resetYaziProfile,
+  yaziProfileDir
+} from "./chunk-J5LZHVIT.js";
+import {
+  normalizedSkillHash,
+  stripProvenanceFrontmatter
+} from "./chunk-NDDGJUXD.js";
+import {
+  resolveToolBinary
+} from "./chunk-QSNYB6ZV.js";
+import {
+  findPinnedTool
+} from "./chunk-QDC3K2U3.js";
+import {
+  initializeClioHome
+} from "./chunk-7PWAODYW.js";
+import {
+  settingsPath,
+  withSettingsLock
+} from "./chunk-EIMVLWB3.js";
+import {
+  resolvePackageRoot
+} from "./chunk-IWHMRKLL.js";
+import {
+  require_dist
+} from "./chunk-APJ265NV.js";
+import {
+  clioStatePath,
+  resolveClioDirs
+} from "./chunk-BYP5D4HI.js";
+import {
+  fsyncDirectory,
+  safeResourceWrite
+} from "./chunk-WEPFGWHJ.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/lifecycle/state.ts
+init_esm_shims();
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+function readStateInfoResult() {
+  const path2 = join(clioStatePath(), "install.json");
+  try {
+    return { info: JSON.parse(readFileSync(path2, "utf8")), problem: null };
+  } catch (error) {
+    const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+    if (code === "ENOENT") return { info: null, problem: null };
+    const message = error instanceof Error ? error.message : String(error);
+    return { info: null, problem: `${path2} could not be read: ${message}` };
+  }
+}
+function readStateInfo() {
+  return readStateInfoResult().info;
+}
+function ensureClioState() {
+  initializeClioHome();
+  const info = readStateInfo();
+  if (!info) throw new Error("state metadata was not written by initializeClioHome()");
+  return info;
+}
+function takeUpgradeNotice() {
+  const path2 = join(clioStatePath(), "install.json");
+  let raw;
+  try {
+    const parsed = JSON.parse(readFileSync(path2, "utf8"));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+    raw = parsed;
+  } catch {
+    return null;
+  }
+  const { version, upgradedFrom, noticedVersion } = raw;
+  if (typeof version !== "string" || typeof upgradedFrom !== "string") return null;
+  if (upgradedFrom === version || noticedVersion === version) return null;
+  try {
+    writeFileSync(path2, `${JSON.stringify({ ...raw, noticedVersion: version }, null, 2)}
+`, "utf8");
+  } catch {
+  }
+  return { from: upgradedFrom, to: version };
+}
+
+// src/domains/lifecycle/naming-resources.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import path from "node:path";
+var LEGACY_SKILL_NAMES = [
+  ["clio-dev", "clio-coder-dev"],
+  ["clio-test", "clio-coder-test"]
+];
+function canonicalizeNamingText(text) {
+  return text.replaceAll("clio-dev", "clio-coder-dev").replaceAll("clio-test", "clio-coder-test").replace(/^clio:/gmu, "clio-coder:").replace(/^(\s*source:\s*)clio\s*$/gmu, "$1clio-coder");
+}
+function installedHash(raw) {
+  const match = raw.match(/^\s*installed-hash:\s*["']?([0-9a-f]{64})["']?\s*$/mu);
+  return match?.[1] ?? null;
+}
+function regularFiles(root, current = root) {
+  const out = [];
+  for (const entry of readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    const full = path.join(current, entry.name);
+    if (entry.isDirectory()) out.push(...regularFiles(root, full));
+    else if (entry.isFile()) out.push(path.relative(root, full));
+    else return [];
+  }
+  return out;
+}
+function provesUnmodifiedShippedCopy(legacyDir, canonicalBundleDir) {
+  let legacyFiles;
+  let canonicalFiles;
+  try {
+    legacyFiles = regularFiles(legacyDir);
+    canonicalFiles = regularFiles(canonicalBundleDir);
+  } catch {
+    return false;
+  }
+  if (legacyFiles.length === 0 || legacyFiles.join("\0") !== canonicalFiles.join("\0")) return false;
+  for (const relative of legacyFiles) {
+    const legacyRaw = readFileSync2(path.join(legacyDir, relative), "utf8");
+    const canonicalRaw = readFileSync2(path.join(canonicalBundleDir, relative), "utf8");
+    if (relative === "SKILL.md") {
+      const recordedHash = installedHash(legacyRaw);
+      if (recordedHash === null || recordedHash !== normalizedSkillHash(legacyRaw)) return false;
+      if (canonicalizeNamingText(stripProvenanceFrontmatter(legacyRaw)) !== stripProvenanceFrontmatter(canonicalRaw))
+        return false;
+      continue;
+    }
+    if (canonicalizeNamingText(legacyRaw) !== canonicalRaw) return false;
+  }
+  return true;
+}
+function rewriteStagedCopy(stage, canonicalBundleDir) {
+  const canonicalSkillHash = normalizedSkillHash(readFileSync2(path.join(canonicalBundleDir, "SKILL.md"), "utf8"));
+  for (const relative of regularFiles(stage)) {
+    const file = path.join(stage, relative);
+    let next = canonicalizeNamingText(readFileSync2(file, "utf8"));
+    if (relative === "SKILL.md") {
+      next = next.replace(/^(\s*installed-hash:\s*).+$/mu, `$1"${canonicalSkillHash}"`);
+    }
+    writeFileSync2(file, next, "utf8");
+  }
+}
+var resourceSwapSequence = 0;
+function migrateProvenSkill(legacyDir, canonicalDir, canonicalBundleDir) {
+  const suffix = `${process.pid}-${++resourceSwapSequence}`;
+  const stage = `${canonicalDir}.clio-coder-naming-stage-${suffix}`;
+  const backup = `${legacyDir}.clio-coder-naming-backup-${suffix}`;
+  mkdirSync(path.dirname(canonicalDir), { recursive: true });
+  cpSync(legacyDir, stage, { recursive: true });
+  try {
+    rewriteStagedCopy(stage, canonicalBundleDir);
+    renameSync(legacyDir, backup);
+    try {
+      renameSync(stage, canonicalDir);
+    } catch (error) {
+      renameSync(backup, legacyDir);
+      throw error;
+    }
+    rmSync(backup, { recursive: true, force: true });
+    fsyncDirectory(path.dirname(canonicalDir));
+  } catch (error) {
+    rmSync(stage, { recursive: true, force: true });
+    throw error;
+  }
+}
+function existingDirectory(candidate) {
+  try {
+    return statSync(candidate).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function inspectInstalledNamingResources(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const configDir = options.configDir ?? resolveClioDirs().config;
+  const packageRoot = options.packageRoot ?? resolvePackageRoot();
+  const roots = [path.join(configDir, "skills"), path.join(cwd, ".clio-coder", "skills")];
+  const reports = [];
+  for (const root of roots) {
+    for (const [legacyName, canonicalName] of LEGACY_SKILL_NAMES) {
+      const legacyPath = path.join(root, legacyName);
+      const canonicalPath = path.join(root, canonicalName);
+      if (!existingDirectory(legacyPath)) {
+        reports.push({ kind: "skill", legacyPath, canonicalPath, status: "absent", detail: "legacy skill absent" });
+        continue;
+      }
+      if (existsSync(canonicalPath)) {
+        reports.push({
+          kind: "skill",
+          legacyPath,
+          canonicalPath,
+          status: "canonical-present",
+          detail: "canonical skill already exists; legacy copy left untouched"
+        });
+        continue;
+      }
+      const canonicalBundleDir = path.join(packageRoot, "skills", "meta", canonicalName);
+      if (!existingDirectory(canonicalBundleDir) || !provesUnmodifiedShippedCopy(legacyPath, canonicalBundleDir)) {
+        reports.push({
+          kind: "skill",
+          legacyPath,
+          canonicalPath,
+          status: "modified",
+          detail: "frontmatter/provenance/hash do not prove an unmodified shipped copy; left untouched"
+        });
+        continue;
+      }
+      if (options.fix) migrateProvenSkill(legacyPath, canonicalPath, canonicalBundleDir);
+      reports.push({
+        kind: "skill",
+        legacyPath,
+        canonicalPath,
+        status: options.fix ? "renamed" : "renamable",
+        detail: options.fix ? "proven unmodified shipped copy renamed and canonicalized" : "proven unmodified shipped copy can be renamed by doctor --fix"
+      });
+    }
+  }
+  return reports;
+}
+function collectSkillFiles(root, current = root) {
+  if (!existingDirectory(current)) return [];
+  const out = [];
+  for (const entry of readdirSync(current, { withFileTypes: true })) {
+    const full = path.join(current, entry.name);
+    if (entry.isDirectory()) out.push(...collectSkillFiles(root, full));
+    else if (entry.isFile() && entry.name === "SKILL.md") out.push(full);
+  }
+  return out;
+}
+function inspectSkillMetadataNaming(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const configDir = options.configDir ?? resolveClioDirs().config;
+  const roots = [path.join(configDir, "skills"), path.join(cwd, ".clio-coder", "skills")];
+  return roots.flatMap(
+    (root) => collectSkillFiles(root).map((file) => ({
+      path: file,
+      legacyMetadataKey: /^clio:\s*(?:#.*)?$/mu.test(readFileSync2(file, "utf8"))
+    }))
+  );
+}
+function countLegacyModelMetadata(value) {
+  if (Array.isArray(value)) return value.reduce((count, entry) => count + countLegacyModelMetadata(entry), 0);
+  if (typeof value !== "object" || value === null) return 0;
+  const record = value;
+  return (Object.hasOwn(record, "clio") ? 1 : 0) + Object.values(record).reduce((count, entry) => count + countLegacyModelMetadata(entry), 0);
+}
+function inspectModelOverlayNaming(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const configDir = options.configDir ?? resolveClioDirs().config;
+  const roots = [path.join(configDir, "model-catalog.d"), path.join(cwd, ".clio-coder", "model-catalog.d")];
+  const inspections = [];
+  for (const root of roots) {
+    if (!existingDirectory(root)) continue;
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith(".yaml") && !entry.name.endsWith(".yml")) continue;
+      const file = path.join(root, entry.name);
+      let legacyMetadataKeys = 0;
+      try {
+        legacyMetadataKeys = countLegacyModelMetadata((0, import_yaml.parse)(readFileSync2(file, "utf8")));
+      } catch {
+      }
+      inspections.push({
+        path: file,
+        legacyFile: entry.name === "clio-local-coding-targets.yaml",
+        legacyMetadataKeys
+      });
+    }
+  }
+  return inspections;
+}
+
+// src/domains/lifecycle/naming-tool-markers.ts
+init_esm_shims();
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync3, renameSync as renameSync2, rmSync as rmSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+var LEGACY_TOOL_MARKER = "clio-install.json";
+var CANONICAL_TOOL_MARKER = "clio-coder-install.json";
+function childDirectories(root) {
+  try {
+    return readdirSync2(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
+  } catch {
+    return [];
+  }
+}
+function readValidMarker(path2, tool, version) {
+  try {
+    const value = JSON.parse(readFileSync3(path2, "utf8"));
+    if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+    const marker = value;
+    if (marker.id !== tool || marker.version !== version) return null;
+    if (typeof marker.sha256 !== "string" || !/^[0-9a-f]{64}$/u.test(marker.sha256)) return null;
+    return { id: tool, version, sha256: marker.sha256 };
+  } catch {
+    return null;
+  }
+}
+function sameFacts(left, right) {
+  return left.id === right.id && left.version === right.version && left.sha256 === right.sha256;
+}
+function inspectToolMarkerNaming(options = {}) {
+  const toolsRoot = join2(options.dataDir ?? resolveClioDirs().data, "tools");
+  const reports = [];
+  for (const tool of childDirectories(toolsRoot)) {
+    if (findPinnedTool(tool) === null) continue;
+    for (const version of childDirectories(join2(toolsRoot, tool))) {
+      const dir = join2(toolsRoot, tool, version);
+      const legacyPath = join2(dir, LEGACY_TOOL_MARKER);
+      if (!existsSync2(legacyPath)) continue;
+      const canonicalPath = join2(dir, CANONICAL_TOOL_MARKER);
+      const legacy = readValidMarker(legacyPath, tool, version);
+      if (legacy === null) {
+        reports.push({
+          tool,
+          version,
+          legacyPath,
+          canonicalPath,
+          status: "invalid-legacy",
+          detail: "legacy marker does not match its known tool/version path and checksum shape; left untouched"
+        });
+        continue;
+      }
+      if (!existsSync2(canonicalPath)) {
+        if (options.fix) {
+          renameSync2(legacyPath, canonicalPath);
+          fsyncDirectory(dir);
+        }
+        reports.push({
+          tool,
+          version,
+          legacyPath,
+          canonicalPath,
+          status: options.fix ? "renamed" : "renamable",
+          detail: options.fix ? "validated legacy marker renamed atomically" : "validated legacy marker can be renamed"
+        });
+        continue;
+      }
+      const canonical = readValidMarker(canonicalPath, tool, version);
+      if (canonical === null || !sameFacts(legacy, canonical)) {
+        reports.push({
+          tool,
+          version,
+          legacyPath,
+          canonicalPath,
+          status: "canonical-conflict",
+          detail: "canonical and legacy marker facts disagree or canonical is invalid; canonical wins and legacy is left untouched"
+        });
+        continue;
+      }
+      if (options.fix) {
+        rmSync2(legacyPath);
+        fsyncDirectory(dir);
+      }
+      reports.push({
+        tool,
+        version,
+        legacyPath,
+        canonicalPath,
+        status: options.fix ? "duplicate-removed" : "agreeing-duplicate",
+        detail: options.fix ? "validated agreeing legacy duplicate removed; canonical marker kept" : "canonical and legacy facts agree; legacy duplicate can be removed"
+      });
+    }
+  }
+  return reports;
+}
+
+// src/domains/lifecycle/naming-yazi.ts
+init_esm_shims();
+import { readFileSync as readFileSync4, statSync as statSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+function occurrences(text, pattern) {
+  return [...text.matchAll(pattern)].length;
+}
+function inspectYaziNaming(cacheDir = resolveClioDirs().cache) {
+  const profileDir = yaziProfileDir(cacheDir);
+  const present = statSync2(profileDir, { throwIfNoEntry: false })?.isDirectory() === true;
+  let keymap = "";
+  try {
+    keymap = readFileSync4(join3(profileDir, "keymap.toml"), "utf8");
+  } catch {
+  }
+  return {
+    profileDir,
+    present,
+    legacyEvents: occurrences(keymap, /(?<!clio-coder-)clio-pick/gmu),
+    legacyEnvironmentNames: occurrences(keymap, /\$CLIO_YAZI_PICK_TOKEN\b/gmu)
+  };
+}
+function regenerateYaziNamingProfile(options = {}) {
+  const cacheDir = options.cacheDir ?? resolveClioDirs().cache;
+  const before = inspectYaziNaming(cacheDir);
+  if (!before.present) {
+    return { ...before, status: "absent", detail: "managed Yazi profile is absent; next open writes canonical names" };
+  }
+  if (before.legacyEvents === 0 && before.legacyEnvironmentNames === 0) {
+    return { ...before, status: "canonical", detail: "managed Yazi profile already uses canonical names" };
+  }
+  const yaziPath = options.yaziPath === void 0 ? resolveToolBinary("yazi").binaryPath : options.yaziPath;
+  const yaPath = options.yaPath === void 0 ? resolveToolBinary("ya").binaryPath : options.yaPath;
+  resetYaziProfile(before.profileDir);
+  if (!yaziPath || !yaPath) {
+    return {
+      ...before,
+      status: "removed-unresolved",
+      detail: "legacy managed profile removed; Yazi/ya is unresolved, so the next managed open will regenerate it"
+    };
+  }
+  const profile = ensureYaziProfile({ yaziPath, yaPath, profileDir: before.profileDir });
+  if (!profile) {
+    return {
+      ...before,
+      status: "regeneration-failed",
+      detail: "legacy managed profile removed, but current Yazi rejected the regenerated profile"
+    };
+  }
+  return { ...before, status: "regenerated", detail: "managed Yazi profile regenerated with canonical names" };
+}
+
+// src/domains/lifecycle/migrations/2026-09-01-clio-coder-naming.ts
+init_esm_shims();
+var import_yaml2 = __toESM(require_dist(), 1);
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync6 } from "node:fs";
+import { join as join5 } from "node:path";
+
+// src/domains/lifecycle/naming-mutable-state.ts
+init_esm_shims();
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "node:fs";
+import { join as join4 } from "node:path";
+var MUTABLE_NAMING_BACKUP_SUFFIX = ".pre-clio-coder-naming.bak";
+var MUTABLE_STATE_FILES = [
+  "dispatch-admission.json",
+  "dispatch-verification-memo.json",
+  "endpoint-slots.json",
+  "fleet-preflight.json",
+  "interop.json"
+];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function transformMutableNamingState(value) {
+  const next = structuredClone(value);
+  const counts = { lifecycle: 0, toolGovernance: 0, source: 0 };
+  const visit = (current) => {
+    if (Array.isArray(current)) {
+      for (const entry of current) visit(entry);
+      return;
+    }
+    if (!isRecord(current)) return;
+    for (const [key, entry] of Object.entries(current)) {
+      if (key === "lifecycle" && entry === "clio-managed") {
+        current[key] = "clio-coder-managed";
+        counts.lifecycle += 1;
+        continue;
+      }
+      if (key === "toolGovernance" && entry === "clio-policy") {
+        current[key] = "clio-coder-policy";
+        counts.toolGovernance += 1;
+        continue;
+      }
+      if (key === "source" && entry === "clio") {
+        current[key] = "clio-coder";
+        counts.source += 1;
+        continue;
+      }
+      visit(entry);
+    }
+  };
+  visit(next);
+  return { value: next, counts };
+}
+function total(counts) {
+  return counts.lifecycle + counts.toolGovernance + counts.source;
+}
+function migrateMutableNamingState(stateDir) {
+  const reports = [];
+  for (const name of MUTABLE_STATE_FILES) {
+    const path2 = join4(stateDir, name);
+    if (!existsSync3(path2)) continue;
+    try {
+      const parsed = JSON.parse(readFileSync5(path2, "utf8"));
+      const transformed = transformMutableNamingState(parsed);
+      const changed = total(transformed.counts) > 0;
+      const backupPath = changed ? `${path2}${MUTABLE_NAMING_BACKUP_SUFFIX}` : null;
+      if (changed) {
+        safeResourceWrite(path2, `${JSON.stringify(transformed.value, null, 2)}
+`, {
+          encoding: "utf8",
+          backup: { path: backupPath }
+        });
+      }
+      reports.push({ path: path2, changed, backupPath, counts: transformed.counts, error: null });
+    } catch (error) {
+      reports.push({
+        path: path2,
+        changed: false,
+        backupPath: null,
+        counts: { lifecycle: 0, toolGovernance: 0, source: 0 },
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return reports;
+}
+
+// src/domains/lifecycle/migrations/2026-09-01-clio-coder-naming.ts
+var CLIO_CODER_NAMING_MIGRATION_ID = "2026-09-01-clio-coder-naming";
+var CLIO_CODER_NAMING_SETTINGS_BACKUP_SUFFIX = ".pre-clio-coder-naming.bak";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function visitNamingValues(value, path2, replacements, conflicts) {
+  if (Array.isArray(value)) {
+    for (const [index, entry] of value.entries()) visitNamingValues(entry, `${path2}[${index}]`, replacements, conflicts);
+    return;
+  }
+  if (!isPlainObject(value)) return;
+  for (const [key, entry] of Object.entries(value)) {
+    const entryPath = path2 ? `${path2}.${key}` : key;
+    if (key === "lifecycle" && entry === "clio-managed") {
+      value[key] = "clio-coder-managed";
+      replacements.push(`${entryPath}: clio-managed -> clio-coder-managed`);
+      continue;
+    }
+    if (key === "toolGovernance" && entry === "clio-policy") {
+      value[key] = "clio-coder-policy";
+      replacements.push(`${entryPath}: clio-policy -> clio-coder-policy`);
+      continue;
+    }
+    if (key === "keybindings" && isPlainObject(entry)) {
+      for (const legacyKey of Object.keys(entry).filter((name) => name.startsWith("clio."))) {
+        const canonicalKey = `clio-coder.${legacyKey.slice("clio.".length)}`;
+        const legacyPath = `${entryPath}.${legacyKey}`;
+        if (Object.hasOwn(entry, canonicalKey)) {
+          delete entry[legacyKey];
+          conflicts.push(`${legacyPath}: discarded because canonical ${entryPath}.${canonicalKey} wins`);
+          continue;
+        }
+        entry[canonicalKey] = entry[legacyKey];
+        delete entry[legacyKey];
+        replacements.push(`${legacyPath} -> ${entryPath}.${canonicalKey}`);
+      }
+    }
+    visitNamingValues(entry, entryPath, replacements, conflicts);
+  }
+}
+function transformNamingSettingsDocument(raw) {
+  if (!isPlainObject(raw)) throw new Error("Clio Coder naming migration expected a YAML map at the document root");
+  const document = structuredClone(raw);
+  const replacements = [];
+  const conflicts = [];
+  visitNamingValues(document, "", replacements, conflicts);
+  return { document, replacements, conflicts };
+}
+function migrateNamingSettingsFile(path2) {
+  if (!existsSync4(path2)) return { path: path2, changed: false, backupPath: null, replacements: [], conflicts: [] };
+  let parsed;
+  try {
+    parsed = (0, import_yaml2.parse)(readFileSync6(path2, "utf8"));
+  } catch (error) {
+    throw new Error(
+      `Clio Coder naming migration could not read and parse ${path2}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const transformed = transformNamingSettingsDocument(parsed);
+  const changed = transformed.replacements.length > 0 || transformed.conflicts.length > 0;
+  if (!changed) {
+    return {
+      path: path2,
+      changed: false,
+      backupPath: null,
+      replacements: transformed.replacements,
+      conflicts: transformed.conflicts
+    };
+  }
+  const backupPath = `${path2}${CLIO_CODER_NAMING_SETTINGS_BACKUP_SUFFIX}`;
+  safeResourceWrite(path2, (0, import_yaml2.stringify)(transformed.document), {
+    encoding: "utf8",
+    mode: 420,
+    backup: { path: backupPath }
+  });
+  return {
+    path: path2,
+    changed: true,
+    backupPath,
+    replacements: transformed.replacements,
+    conflicts: transformed.conflicts
+  };
+}
+function namingMigrationReportPath(stateDir) {
+  return join5(stateDir, "migration-reports", `${CLIO_CODER_NAMING_MIGRATION_ID}.json`);
+}
+var migration = {
+  id: CLIO_CODER_NAMING_MIGRATION_ID,
+  async up(stateDir) {
+    const settings = [];
+    withSettingsLock(() => settings.push(migrateNamingSettingsFile(settingsPath())));
+    const report = {
+      migrationId: CLIO_CODER_NAMING_MIGRATION_ID,
+      version: 1,
+      settings,
+      toolMarkers: inspectToolMarkerNaming({ fix: true }),
+      resources: inspectInstalledNamingResources({ fix: true }),
+      yazi: [regenerateYaziNamingProfile()],
+      mutableState: migrateMutableNamingState(stateDir)
+    };
+    const target = namingMigrationReportPath(stateDir);
+    mkdirSync2(join5(stateDir, "migration-reports"), { recursive: true });
+    safeResourceWrite(target, `${JSON.stringify(report, null, 2)}
+`, { encoding: "utf8", mode: 420 });
+  }
+};
+var clio_coder_naming_default = migration;
+
+export {
+  readStateInfoResult,
+  readStateInfo,
+  ensureClioState,
+  takeUpgradeNotice,
+  inspectInstalledNamingResources,
+  inspectSkillMetadataNaming,
+  inspectModelOverlayNaming,
+  inspectToolMarkerNaming,
+  inspectYaziNaming,
+  regenerateYaziNamingProfile,
+  transformNamingSettingsDocument,
+  migrateNamingSettingsFile,
+  clio_coder_naming_default
+};
+//# sourceMappingURL=chunk-QTFGO774.js.map