muonroi-cli 1.4.0 → 1.5.0

package/src/utils/install-manager.ts

@@ -1,429 +0,0 @@
-import { spawn } from "child_process";
-import { createHash } from "crypto";
-import fs from "fs";
-import os from "os";
-import path from "path";
-import readline from "readline";
-import semverGt from "semver/functions/gt.js";
-import semverValid from "semver/functions/valid.js";
-
-export const GITHUB_REPO = "muonroi/muonroi-cli";
-export const RELEASES_API = `https://api.github.com/repos/${GITHUB_REPO}/releases`;
-export const SCRIPT_INSTALL_METHOD = "script";
-
-const FETCH_TIMEOUT_MS = 5_000;
-const INSTALL_SCHEMA_VERSION = 1;
-const PATH_MARKER = "# muonroi-cli";
-const CONFIG_FILENAMES = ["user-settings.json", "AGENTS.md"];
-const DATA_ENTRIES = ["daemon.pid", "delegations", "muonroi.db", "models", "schedules"];
-
-export interface ReleaseTarget {
-  key: "darwin-arm64" | "linux-x64" | "windows-x64";
-  assetName: string;
-  binaryName: string;
-}
-
-export interface ScriptInstallMetadata {
-  schemaVersion: number;
-  installMethod: typeof SCRIPT_INSTALL_METHOD;
-  version: string;
-  repo: string;
-  binaryPath: string;
-  installDir: string;
-  assetName: string;
-  target: ReleaseTarget["key"];
-  installedAt: string;
-  shellConfigPath?: string;
-  pathCommand?: string;
-}
-
-export interface ScriptInstallContext {
-  metadata: ScriptInstallMetadata;
-  target: ReleaseTarget;
-  binaryPath: string;
-}
-
-export interface ScriptUpdateRunResult {
-  success: boolean;
-  output: string;
-}
-
-export interface ScriptUninstallOptions {
-  dryRun?: boolean;
-  force?: boolean;
-  keepConfig?: boolean;
-  keepData?: boolean;
-}
-
-export interface ScriptUninstallPlan {
-  removePaths: string[];
-  pruneDirs: string[];
-  pathCleanup?: { configFile: string; command: string };
-}
-
-interface GitHubReleaseAsset {
-  name: string;
-  browser_download_url: string;
-}
-
-interface GitHubRelease {
-  tag_name: string;
-  assets: GitHubReleaseAsset[];
-}
-
-interface ReleaseDownload {
-  version: string;
-  asset: GitHubReleaseAsset;
-  checksums: GitHubReleaseAsset;
-}
-
-export function getUserDir(homeDir = os.homedir()): string {
-  return path.join(homeDir, ".muonroi-cli");
-}
-
-export function getScriptInstallDir(homeDir = os.homedir()): string {
-  return path.join(getUserDir(homeDir), "bin");
-}
-
-export function getInstallMetadataPath(homeDir = os.homedir()): string {
-  return path.join(getUserDir(homeDir), "install.json");
-}
-
-export function getReleaseTargetForPlatform(platform = process.platform, arch = process.arch): ReleaseTarget | null {
-  if (platform === "darwin" && (arch === "arm64" || arch === "x64"))
-    return { key: "darwin-arm64", assetName: "muonroi-cli-darwin-arm64", binaryName: "muonroi-cli" };
-  if (platform === "linux" && arch === "x64")
-    return { key: "linux-x64", assetName: "muonroi-cli-linux-x64", binaryName: "muonroi-cli" };
-  if (platform === "win32" && arch === "x64")
-    return { key: "windows-x64", assetName: "muonroi-cli-windows-x64.exe", binaryName: "muonroi-cli.exe" };
-  return null;
-}
-
-export function loadScriptInstallMetadata(homeDir = os.homedir()): ScriptInstallMetadata | null {
-  const metadataPath = getInstallMetadataPath(homeDir);
-  try {
-    if (!fs.existsSync(metadataPath)) return null;
-    const parsed = JSON.parse(fs.readFileSync(metadataPath, "utf8")) as Partial<ScriptInstallMetadata>;
-    if (parsed.installMethod !== SCRIPT_INSTALL_METHOD) return null;
-    if (
-      typeof parsed.binaryPath !== "string" ||
-      typeof parsed.installDir !== "string" ||
-      typeof parsed.assetName !== "string" ||
-      typeof parsed.target !== "string"
-    )
-      return null;
-    return {
-      schemaVersion: INSTALL_SCHEMA_VERSION,
-      installMethod: SCRIPT_INSTALL_METHOD,
-      version: typeof parsed.version === "string" ? parsed.version : "unknown",
-      repo: typeof parsed.repo === "string" ? parsed.repo : GITHUB_REPO,
-      binaryPath: parsed.binaryPath,
-      installDir: parsed.installDir,
-      assetName: parsed.assetName,
-      target: parsed.target as ReleaseTarget["key"],
-      installedAt: typeof parsed.installedAt === "string" ? parsed.installedAt : new Date(0).toISOString(),
-      shellConfigPath: typeof parsed.shellConfigPath === "string" ? parsed.shellConfigPath : undefined,
-      pathCommand: typeof parsed.pathCommand === "string" ? parsed.pathCommand : undefined,
-    };
-  } catch {
-    return null;
-  }
-}
-
-export function saveScriptInstallMetadata(metadata: ScriptInstallMetadata, homeDir = os.homedir()): void {
-  const metadataPath = getInstallMetadataPath(homeDir);
-  fs.mkdirSync(path.dirname(metadataPath), { recursive: true, mode: 0o700 });
-  fs.writeFileSync(metadataPath, `${JSON.stringify(metadata, null, 2)}\n`, { mode: 0o600 });
-}
-
-export function getScriptInstallContext(homeDir = os.homedir()): ScriptInstallContext | null {
-  const target = getReleaseTargetForPlatform();
-  if (!target) return null;
-
-  const metadata = loadScriptInstallMetadata(homeDir);
-  if (metadata) {
-    return {
-      metadata,
-      target: getReleaseTargetForPlatformKey(metadata.target) ?? target,
-      binaryPath: metadata.binaryPath,
-    };
-  }
-
-  return null;
-}
-
-export async function fetchLatestReleaseVersion(): Promise<string | null> {
-  const release = await fetchReleaseJson(`${RELEASES_API}/latest`);
-  return release ? normalizeReleaseVersion(release.tag_name) : null;
-}
-
-export function parseChecksumsFile(contents: string): Map<string, string> {
-  const result = new Map<string, string>();
-  for (const rawLine of contents.split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (!line) continue;
-    const match = line.match(/^([a-fA-F0-9]{64})\s+\*?(.+)$/);
-    if (!match) continue;
-    result.set(match[2], match[1].toLowerCase());
-  }
-  return result;
-}
-
-export async function runScriptManagedUpdate(currentVersion: string): Promise<ScriptUpdateRunResult> {
-  const context = getScriptInstallContext();
-  if (!context) return notScriptManaged("update");
-
-  const normalizedCurrent = semverValid(currentVersion);
-  if (!normalizedCurrent) {
-    return { success: false, output: `Cannot update: current version "${currentVersion}" is invalid.` };
-  }
-
-  const release = await resolveReleaseDownload(context.target);
-  if (!release) {
-    return { success: false, output: "No matching release found for this platform." };
-  }
-
-  if (!semverGt(release.version, normalizedCurrent)) {
-    return { success: true, output: `Already on the latest version (${normalizedCurrent}).` };
-  }
-
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "muonroi-cli-update-"));
-  try {
-    const downloadedPath = path.join(tempDir, release.asset.name);
-    await downloadBinary(release.asset.browser_download_url, downloadedPath);
-
-    const checksumsText = await downloadText(release.checksums.browser_download_url);
-    const expectedHash = parseChecksumsFile(checksumsText).get(release.asset.name);
-    if (!expectedHash) return { success: false, output: `Missing checksum for ${release.asset.name}.` };
-
-    if (sha256File(downloadedPath) !== expectedHash) {
-      return { success: false, output: `Checksum mismatch for ${release.asset.name}; aborting.` };
-    }
-
-    fs.mkdirSync(path.dirname(context.binaryPath), { recursive: true, mode: 0o700 });
-
-    if (process.platform === "win32") {
-      return applyWindowsUpdate(tempDir, downloadedPath, context, release);
-    }
-
-    const staging = `${context.binaryPath}.new`;
-    fs.copyFileSync(downloadedPath, staging);
-    fs.chmodSync(staging, 0o755);
-    fs.renameSync(staging, context.binaryPath);
-
-    saveScriptInstallMetadata({
-      ...context.metadata,
-      version: release.version,
-      installedAt: new Date().toISOString(),
-    });
-
-    return { success: true, output: `Updated to muonroi-cli ${release.version}.` };
-  } catch (error) {
-    return { success: false, output: error instanceof Error ? error.message : String(error) };
-  } finally {
-    if (process.platform !== "win32") fs.rmSync(tempDir, { recursive: true, force: true });
-  }
-}
-
-export function buildScriptUninstallPlan(
-  options: ScriptUninstallOptions = {},
-  homeDir = os.homedir(),
-): ScriptUninstallPlan | null {
-  const context = getScriptInstallContext(homeDir);
-  if (!context) return null;
-
-  const userDir = getUserDir(homeDir);
-  const removePaths = new Set<string>();
-  const pruneDirs = new Set<string>();
-
-  if (!options.keepConfig && !options.keepData) {
-    removePaths.add(userDir);
-  } else {
-    removePaths.add(context.binaryPath);
-    removePaths.add(getInstallMetadataPath(homeDir));
-    if (!options.keepConfig) for (const f of CONFIG_FILENAMES) removePaths.add(path.join(userDir, f));
-    if (!options.keepData) for (const e of DATA_ENTRIES) removePaths.add(path.join(userDir, e));
-    pruneDirs.add(getScriptInstallDir(homeDir));
-    pruneDirs.add(userDir);
-  }
-
-  return {
-    removePaths: sortForRemoval([...removePaths]),
-    pruneDirs: sortForRemoval([...pruneDirs]),
-    pathCleanup:
-      context.metadata.shellConfigPath && context.metadata.pathCommand
-        ? { configFile: context.metadata.shellConfigPath, command: context.metadata.pathCommand }
-        : undefined,
-  };
-}
-
-export async function runScriptManagedUninstall(options: ScriptUninstallOptions = {}): Promise<ScriptUpdateRunResult> {
-  const plan = buildScriptUninstallPlan(options);
-  if (!plan) return notScriptManaged("uninstall");
-
-  if (options.dryRun) return { success: true, output: formatDryRun(plan, options) };
-
-  if (!options.force) {
-    if (!process.stdin.isTTY || !process.stdout.isTTY) {
-      return { success: false, output: "Non-interactive terminal. Re-run with --force." };
-    }
-    if (!(await confirm("Remove muonroi-cli from this machine?"))) {
-      return { success: false, output: "Uninstall cancelled." };
-    }
-  }
-
-  try {
-    if (plan.pathCleanup) removePathLine(plan.pathCleanup.configFile, plan.pathCleanup.command);
-    for (const p of plan.removePaths) fs.rmSync(p, { recursive: true, force: true });
-    for (const d of plan.pruneDirs) removeDirIfEmpty(d);
-    return { success: true, output: "muonroi-cli uninstall complete." };
-  } catch (error) {
-    return { success: false, output: error instanceof Error ? error.message : String(error) };
-  }
-}
-
-function notScriptManaged(action: string): ScriptUpdateRunResult {
-  return {
-    success: false,
-    output: `This install is not script-managed, so \`muonroi-cli ${action}\` cannot proceed. Use the package manager you installed with, or reinstall via install.sh.`,
-  };
-}
-
-function getReleaseTargetForPlatformKey(key: string): ReleaseTarget | null {
-  switch (key) {
-    case "darwin-arm64":
-      return { key, assetName: "muonroi-cli-darwin-arm64", binaryName: "muonroi-cli" };
-    case "darwin-x64":
-      return { key: "darwin-arm64", assetName: "muonroi-cli-darwin-arm64", binaryName: "muonroi-cli" };
-    case "linux-x64":
-      return { key, assetName: "muonroi-cli-linux-x64", binaryName: "muonroi-cli" };
-    case "windows-x64":
-      return { key, assetName: "muonroi-cli-windows-x64.exe", binaryName: "muonroi-cli.exe" };
-    default:
-      return null;
-  }
-}
-
-async function resolveReleaseDownload(target: ReleaseTarget): Promise<ReleaseDownload | null> {
-  const release = await fetchReleaseJson(`${RELEASES_API}/latest`);
-  if (!release) return null;
-  const version = normalizeReleaseVersion(release.tag_name);
-  if (!version) return null;
-
-  const asset = release.assets.find((a) => a.name === target.assetName);
-  const checksums = release.assets.find((a) => a.name === "checksums.txt");
-  if (!asset || !checksums) return null;
-
-  return { version, asset, checksums };
-}
-
-async function fetchReleaseJson(url: string): Promise<GitHubRelease | null> {
-  try {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-    const res = await fetch(url, { signal: controller.signal, headers: { Accept: "application/vnd.github+json" } });
-    clearTimeout(timer);
-    return res.ok ? ((await res.json()) as GitHubRelease) : null;
-  } catch {
-    return null;
-  }
-}
-
-function normalizeReleaseVersion(tagName: string): string | null {
-  let version = tagName;
-  if (version.startsWith("muonroi-cli-dev@")) version = version.slice("muonroi-cli-dev@".length);
-  if (version.startsWith("v")) version = version.slice(1);
-  return semverValid(version);
-}
-
-async function downloadBinary(url: string, dest: string): Promise<void> {
-  const res = await fetch(url, { headers: { Accept: "application/octet-stream" } });
-  if (!res.ok) throw new Error(`Download failed (${res.status}) for ${url}`);
-  fs.writeFileSync(dest, Buffer.from(await res.arrayBuffer()));
-}
-
-async function downloadText(url: string): Promise<string> {
-  const res = await fetch(url, { headers: { Accept: "text/plain" } });
-  if (!res.ok) throw new Error(`Download failed (${res.status}) for ${url}`);
-  return await res.text();
-}
-
-function sha256File(filePath: string): string {
-  return createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
-}
-
-function sortForRemoval(paths: string[]): string[] {
-  return [...new Set(paths)].sort((a, b) => b.length - a.length);
-}
-
-function removeDirIfEmpty(dir: string): void {
-  try {
-    if (fs.existsSync(dir) && fs.readdirSync(dir).length === 0) fs.rmdirSync(dir);
-  } catch {
-    /* best effort */
-  }
-}
-
-function removePathLine(configFile: string, command: string): void {
-  if (!fs.existsSync(configFile)) return;
-  const lines = fs.readFileSync(configFile, "utf8").split(/\r?\n/);
-  fs.writeFileSync(
-    configFile,
-    `${lines
-      .filter((l) => l !== PATH_MARKER && l !== command)
-      .join("\n")
-      .replace(/\n+$/, "")}\n`,
-  );
-}
-
-function formatDryRun(plan: ScriptUninstallPlan, options: ScriptUninstallOptions): string {
-  const lines = ["Dry run — would perform:"];
-  if (plan.pathCleanup) lines.push(`  remove PATH entry from ${plan.pathCleanup.configFile}`);
-  for (const p of plan.removePaths) lines.push(`  remove ${p}`);
-  if (options.keepConfig) lines.push("  keep config files");
-  if (options.keepData) lines.push("  keep data files");
-  return lines.join("\n");
-}
-
-async function confirm(prompt: string): Promise<boolean> {
-  return new Promise((resolve) => {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    rl.question(`${prompt} [y/N] `, (answer) => {
-      rl.close();
-      resolve(/^y(es)?$/i.test(answer.trim()));
-    });
-  });
-}
-
-function applyWindowsUpdate(
-  tempDir: string,
-  downloadedPath: string,
-  context: ScriptInstallContext,
-  release: ReleaseDownload,
-): ScriptUpdateRunResult {
-  const script = [
-    "$ErrorActionPreference = 'Stop'",
-    "Start-Sleep -Seconds 2",
-    `Move-Item -LiteralPath '${esc(downloadedPath)}' -Destination '${esc(context.binaryPath)}' -Force`,
-  ].join("\n");
-
-  const scriptPath = path.join(tempDir, "apply-update.ps1");
-  fs.writeFileSync(scriptPath, script);
-
-  saveScriptInstallMetadata({ ...context.metadata, version: release.version, installedAt: new Date().toISOString() });
-
-  const child = spawn("powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", scriptPath], {
-    detached: true,
-    stdio: "ignore",
-  });
-  child.unref();
-
-  return {
-    success: true,
-    output: `Updated to muonroi-cli ${release.version}. Restart the CLI to use the new version.`,
-  };
-}
-
-function esc(s: string): string {
-  return s.replace(/'/g, "''");
-}

package/src/utils/instructions.test.ts

@@ -1,112 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-function makeTempDir(prefix: string): string {
-  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-}
-
-function writeFile(filePath: string, content: string): void {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, content);
-}
-
-async function importLoadCustomInstructions(mockedHome?: string) {
-  vi.resetModules();
-  vi.doUnmock("os");
-
-  if (mockedHome) {
-    process.env.HOME = mockedHome;
-    vi.doMock("os", async () => {
-      const actual = await vi.importActual<typeof import("os")>("os");
-      return {
-        ...actual,
-        homedir: () => mockedHome,
-      };
-    });
-  }
-
-  const mod = await import("./instructions");
-  return mod.loadCustomInstructions;
-}
-
-const originalHome = process.env.HOME;
-
-describe("loadCustomInstructions", () => {
-  afterEach(() => {
-    process.env.HOME = originalHome;
-    vi.restoreAllMocks();
-    vi.resetModules();
-    vi.doUnmock("os");
-  });
-
-  it("returns null when no instruction files exist", async () => {
-    const home = makeTempDir("muonroi-home-");
-    const cwd = makeTempDir("muonroi-cwd-");
-    const loadCustomInstructions = await importLoadCustomInstructions(home);
-
-    expect(loadCustomInstructions(cwd)).toBeNull();
-  });
-
-  it("loads global plus repo-chain AGENTS files in order", async () => {
-    const home = makeTempDir("muonroi-home-");
-    const repoRoot = makeTempDir("muonroi-repo-");
-    const cwd = path.join(repoRoot, "pkg", "feature");
-    fs.mkdirSync(path.join(repoRoot, ".git"));
-    fs.mkdirSync(cwd, { recursive: true });
-
-    writeFile(path.join(home, ".muonroi-cli", "AGENTS.md"), "global instructions");
-    writeFile(path.join(repoRoot, "AGENTS.md"), "root instructions");
-    writeFile(path.join(repoRoot, "pkg", "AGENTS.md"), "pkg instructions");
-    writeFile(path.join(repoRoot, "pkg", "feature", "AGENTS.md"), "feature instructions");
-    const loadCustomInstructions = await importLoadCustomInstructions(home);
-
-    expect(loadCustomInstructions(cwd)).toBe(
-      ["global instructions", "root instructions", "pkg instructions", "feature instructions"].join("\n\n"),
-    );
-  });
-
-  it("auto-loads CLAUDE/GEMINI/DEEPSEEK/COPILOT/CURSOR alongside AGENTS.md", async () => {
-    const home = makeTempDir("muonroi-home-");
-    const repoRoot = makeTempDir("muonroi-repo-");
-    const cwd = repoRoot;
-    fs.mkdirSync(path.join(repoRoot, ".git"));
-
-    writeFile(path.join(repoRoot, "AGENTS.md"), "agents body");
-    writeFile(path.join(repoRoot, "CLAUDE.md"), "claude body");
-    writeFile(path.join(repoRoot, "GEMINI.md"), "gemini body");
-    writeFile(path.join(repoRoot, "DEEPSEEK.md"), "deepseek body");
-
-    const loadCustomInstructions = await importLoadCustomInstructions(home);
-    const out = loadCustomInstructions(cwd);
-    expect(out).not.toBeNull();
-    // AGENTS.md first, others tagged with comment headers, in declared order
-    expect(out).toContain("agents body");
-    expect(out).toContain("<!-- CLAUDE.md -->\nclaude body");
-    expect(out).toContain("<!-- GEMINI.md -->\ngemini body");
-    expect(out).toContain("<!-- DEEPSEEK.md -->\ndeepseek body");
-    const idxAgents = out!.indexOf("agents body");
-    const idxClaude = out!.indexOf("claude body");
-    const idxGemini = out!.indexOf("gemini body");
-    const idxDeepseek = out!.indexOf("deepseek body");
-    expect(idxAgents).toBeLessThan(idxClaude);
-    expect(idxClaude).toBeLessThan(idxGemini);
-    expect(idxGemini).toBeLessThan(idxDeepseek);
-  });
-
-  it("prefers AGENTS.override.md over AGENTS.md in the same directory", async () => {
-    const home = makeTempDir("muonroi-home-");
-    const repoRoot = makeTempDir("muonroi-repo-");
-    const cwd = path.join(repoRoot, "nested");
-    fs.mkdirSync(path.join(repoRoot, ".git"));
-    fs.mkdirSync(cwd, { recursive: true });
-
-    writeFile(path.join(repoRoot, "AGENTS.md"), "root instructions");
-    writeFile(path.join(repoRoot, "nested", "AGENTS.md"), "nested base instructions");
-    writeFile(path.join(repoRoot, "nested", "AGENTS.override.md"), "nested override instructions");
-    const loadCustomInstructions = await importLoadCustomInstructions(home);
-
-    expect(loadCustomInstructions(cwd)).toBe(["root instructions", "nested override instructions"].join("\n\n"));
-  });
-});

package/src/utils/instructions.ts

@@ -1,149 +0,0 @@
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { executeEventHooks } from "../hooks/index";
-import type { InstructionsLoadedHookInput } from "../hooks/types";
-import { findGitRoot } from "./git-root";
-
-const instructionsHookFiredFor = new Set<string>();
-
-// --- Instructions cache ---
-const _instructionsCache = new Map<string, { content: string | null; hash: string; cachedAt: number }>();
-const INSTRUCTIONS_CACHE_TTL_MS = 60_000; // 1 minute TTL — files rarely change mid-session
-
-function computeHash(parts: string[]): string {
-  const joined = parts.join("|");
-  return `${joined.length}:${joined.slice(0, 50)}:${joined.slice(-50)}`;
-}
-
-/** Clear the instructions cache (for tests). */
-export function resetInstructionsCache(): void {
-  _instructionsCache.clear();
-}
-
-function readNonEmptyFile(filePath: string): string | null {
-  try {
-    if (!fs.existsSync(filePath)) return null;
-    const text = fs.readFileSync(filePath, "utf-8").trim();
-    return text.length > 0 ? text : null;
-  } catch {
-    return null;
-  }
-}
-
-function directoryChain(fromRoot: string, toCwd: string): string[] {
-  const rel = path.relative(fromRoot, toCwd);
-  if (rel === "") return [fromRoot];
-  if (rel.startsWith("..")) return [toCwd];
-
-  const segments = rel.split(path.sep).filter(Boolean);
-  const chain: string[] = [];
-  let acc = fromRoot;
-  chain.push(acc);
-  for (const segment of segments) {
-    acc = path.join(acc, segment);
-    chain.push(acc);
-  }
-  return chain;
-}
-
-/**
- * Filenames the loader treats as agent-instructions, in the order they are
- * concatenated for a given directory. AGENTS.md stays first as the canonical
- * source; the rest exist so projects already maintaining tool-specific
- * instructions (CLAUDE.md, GEMINI.md, DEEPSEEK.md, COPILOT.md) get auto-loaded
- * without duplicating content into AGENTS.md.
- *
- * AGENTS.override.md remains a wholesale replacement that short-circuits the
- * rest of the per-directory loop.
- */
-const INSTRUCTION_FILENAMES = [
-  "AGENTS.md",
-  "CLAUDE.md",
-  "GEMINI.md",
-  "DEEPSEEK.md",
-  "COPILOT.md",
-  "CURSOR.md",
-] as const;
-
-function readSegmentWithHeader(dir: string, filename: string, label?: string): string | null {
-  const text = readNonEmptyFile(path.join(dir, filename));
-  if (!text) return null;
-  if (filename === "AGENTS.md") return text; // keep AGENTS.md unannotated for backcompat
-  return `<!-- ${label ?? filename} -->\n${text}`;
-}
-
-function loadAgentsSegments(canonicalCwd: string): string[] {
-  const segments: string[] = [];
-
-  const homeDir = path.join(os.homedir(), ".muonroi-cli");
-  for (const fname of INSTRUCTION_FILENAMES) {
-    const seg = readSegmentWithHeader(homeDir, fname, `~/.muonroi-cli/${fname}`);
-    if (seg) segments.push(seg);
-  }
-
-  const root = findGitRoot(canonicalCwd) ?? canonicalCwd;
-  for (const dir of directoryChain(root, canonicalCwd)) {
-    const overridePath = path.join(dir, "AGENTS.override.md");
-    if (fs.existsSync(overridePath)) {
-      const text = readNonEmptyFile(overridePath);
-      if (text) segments.push(text);
-      continue;
-    }
-    for (const fname of INSTRUCTION_FILENAMES) {
-      const rel = path.relative(canonicalCwd, dir);
-      const label = rel === "" ? fname : path.join(rel, fname);
-      const seg = readSegmentWithHeader(dir, fname, label);
-      if (seg) segments.push(seg);
-    }
-  }
-
-  return segments;
-}
-
-export function loadCustomInstructions(cwd: string): string | null {
-  let canonical: string;
-  try {
-    canonical = fs.realpathSync.native(cwd);
-  } catch {
-    canonical = path.resolve(cwd);
-  }
-
-  // Check cache first
-  const now = Date.now();
-  const cached = _instructionsCache.get(canonical);
-  if (cached && now - cached.cachedAt < INSTRUCTIONS_CACHE_TTL_MS) {
-    // Still fire hook on first call even when returning cached content
-    if (cached.content !== null && !instructionsHookFiredFor.has(canonical)) {
-      instructionsHookFiredFor.add(canonical);
-      const hookInput: InstructionsLoadedHookInput = {
-        hook_event_name: "InstructionsLoaded",
-        files_loaded: cached.content.split("\n\n").length,
-        cwd: canonical,
-      };
-      executeEventHooks(hookInput, canonical).catch(() => {});
-    }
-    return cached.content;
-  }
-
-  const parts: string[] = [...loadAgentsSegments(canonical)];
-
-  if (parts.length === 0) {
-    _instructionsCache.set(canonical, { content: null, hash: "", cachedAt: now });
-    return null;
-  }
-
-  if (!instructionsHookFiredFor.has(canonical)) {
-    instructionsHookFiredFor.add(canonical);
-    const hookInput: InstructionsLoadedHookInput = {
-      hook_event_name: "InstructionsLoaded",
-      files_loaded: parts.length,
-      cwd: canonical,
-    };
-    executeEventHooks(hookInput, canonical).catch(() => {});
-  }
-
-  const content = parts.join("\n\n");
-  _instructionsCache.set(canonical, { content, hash: computeHash(parts), cachedAt: now });
-  return content;
-}