@cleocode/cleo 2026.10.3 → 2026.10.4

package/dist/cli/history-EIXADPAD.js

@@ -0,0 +1,137 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import {
+  dispatchFromCli
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/history.ts
+var logCommand = defineCommand({
+  meta: { name: "log", description: "Show operation audit log" },
+  args: {
+    days: {
+      type: "string",
+      description: "Show last N days",
+      default: "30"
+    },
+    since: {
+      type: "string",
+      description: "Show completions since date (YYYY-MM-DD)"
+    },
+    until: {
+      type: "string",
+      description: "Show completions until date (YYYY-MM-DD)"
+    },
+    "no-chart": {
+      type: "boolean",
+      description: "Disable bar charts",
+      default: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "log",
+      {
+        days: Number.parseInt(args.days, 10),
+        since: args.since,
+        until: args.until
+      },
+      { command: "history" }
+    );
+  }
+});
+var workCommand = defineCommand({
+  meta: { name: "work", description: "Show task work history (time tracked per task)" },
+  async run() {
+    await dispatchFromCli("query", "tasks", "history", {}, { command: "history" });
+  }
+});
+var rankingCommand = defineCommand({
+  meta: {
+    name: "ranking",
+    description: "Who changed a task's priority, severity, kind or depends \u2014 actor, session, reason, before/after (D11161)"
+  },
+  args: {
+    taskId: { type: "positional", description: "Task ID", required: true },
+    limit: { type: "string", description: "Maximum entries (default 50)" }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tasks",
+      "history",
+      {
+        taskId: String(args.taskId),
+        ranking: true,
+        ...args.limit !== void 0 ? { limit: Number.parseInt(String(args.limit), 10) } : {}
+      },
+      { command: "history" }
+    );
+  }
+});
+var revertCommand = defineCommand({
+  meta: {
+    name: "revert",
+    description: "Undo one ranking change (an entry id from `cleo history ranking`); refused if a field changed again since, unless --force"
+  },
+  args: {
+    entryId: { type: "positional", description: "ranking_changed entry id", required: true },
+    reason: { type: "string", description: "Why it is reverted (recorded)" },
+    force: { type: "boolean", description: "Revert even though a field changed again since" }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "tasks",
+      "ranking.revert",
+      {
+        entryId: String(args.entryId),
+        ...args.reason !== void 0 ? { reason: String(args.reason) } : {},
+        ...args.force === true ? { force: true } : {}
+      },
+      { command: "history" }
+    );
+  }
+});
+var historyCommand = defineCommand({
+  meta: { name: "history", description: "Completion timeline and productivity analytics" },
+  subCommands: {
+    log: logCommand,
+    work: workCommand,
+    ranking: rankingCommand,
+    revert: revertCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  historyCommand
+};
+//# sourceMappingURL=history-EIXADPAD.js.map

package/dist/cli/hook-UF7J7R6D.js

@@ -0,0 +1,57 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import "./chunk-C3B7C43W.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+
+// packages/cleo/src/cli/commands/hook.ts
+var heavyCommandSubcommand = defineCommand({
+  meta: {
+    name: "heavy-command",
+    description: "PreToolUse hook: route heavy shell commands (tests, builds, typechecks, installs) through cleo run. Reads the hook JSON on stdin; prints the harness answer."
+  },
+  args: {
+    provider: {
+      type: "string",
+      description: "Harness protocol to answer in: claude-code (default), codex, kimi, opencode"
+    }
+  },
+  async run({ args }) {
+    const { runHookCli } = await import("./hook-entry.js");
+    const provider = typeof args.provider === "string" ? args.provider : "claude-code";
+    process.exitCode = await runHookCli(["heavy-command", "--provider", provider]);
+  }
+});
+var hookCommand = defineCommand({
+  meta: {
+    name: "hook",
+    description: "Agent-harness hooks installed by cleo init/upgrade; stdout is the harness hook protocol, not LAFS: cleo hook heavy-command --provider claude-code|codex|kimi|opencode"
+  },
+  subCommands: {
+    "heavy-command": heavyCommandSubcommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  hookCommand
+};
+//# sourceMappingURL=hook-UF7J7R6D.js.map

package/dist/cli/hook-entry.js

@@ -1,4 +1,7 @@
 (() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
   const _origEmitWarning = process.emitWarning;
   process.emitWarning = function(warning, type, code, ctor) {
     if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
@@ -12,7 +15,8 @@
 })();
 
 // packages/cleo/src/cli/hook-entry.ts
-import { readdirSync, readFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 var HEAVY_HOOK_PROVIDERS = [
@@ -27,6 +31,13 @@ var MIN_WAIT_SEC = 30;
 var MAX_WAIT_SEC = 300;
 var DEFAULT_WAIT_SEC = 60;
 var REWRITE_MODES = /* @__PURE__ */ new Set(["bypassPermissions", "auto"]);
+var PRE_APPROVE_MODES = /* @__PURE__ */ new Set([
+  "default",
+  "acceptEdits",
+  "dontAsk",
+  "auto"
+]);
+var PRE_APPROVED_REASON = "[cleo] your allow rules approve this command; the hook only queues it for the machine-wide budget";
 var MAX_STDIN_BYTES = 1024 * 1024;
 async function readProcessStdin() {
   if (process.stdin.isTTY) return "";
@@ -119,7 +130,7 @@ function heavyHookContext(plan, pressure, provider = "claude-code") {
 function demote(plan, reason) {
   return plan.action === "rewrite" ? { action: "warn", reason, segments: plan.segments } : plan;
 }
-function renderHeavyHookAnswer(provider, toolInput, plan, context, timeoutMs) {
+function renderHeavyHookAnswer(provider, toolInput, plan, context, timeoutMs, preApproved = false) {
   if (plan.action === "none" && context === "") return "";
   const rewrite = plan.action === "rewrite";
   if (provider === "opencode") {
@@ -149,10 +160,12 @@ function renderHeavyHookAnswer(provider, toolInput, plan, context, timeoutMs) {
     command: plan.command,
     ...provider === "claude-code" && timeoutMs !== void 0 ? { timeout: timeoutMs } : {}
   } : void 0;
+  const allow = rewrite && (provider === "codex" || preApproved);
   const output = {
     hookSpecificOutput: {
       hookEventName: "PreToolUse",
-      ...rewrite && provider === "codex" ? { permissionDecision: "allow" } : {},
+      ...allow ? { permissionDecision: "allow" } : {},
+      ...allow && provider === "claude-code" ? { permissionDecisionReason: PRE_APPROVED_REASON } : {},
       ...updatedInput === void 0 ? {} : { updatedInput },
       ...context === "" ? {} : { additionalContext: context }
     }
@@ -175,12 +188,33 @@ function heavyRuleWords(argv) {
 function ruleWords(pattern) {
   return pattern.split(/[\s:*()]+/).filter((w) => w !== "" && !w.startsWith("-")).map(wordBase);
 }
-function claudeRuleFiles(projectDir, env) {
-  const managed = process.platform === "darwin" ? "/Library/Application Support/ClaudeCode/managed-settings.json" : process.platform === "win32" ? "C:\\Program Files\\ClaudeCode\\managed-settings.json" : "/etc/claude-code/managed-settings.json";
-  const configDir = env.CLAUDE_CONFIG_DIR || join(env.HOME || homedir(), ".claude");
+function claudeRuleFiles(projectDir, env, managedDir = claudeManagedDir()) {
+  return [...claudeManagedFiles(env, managedDir), ...claudeSettingsFiles(projectDir, env)];
+}
+function claudeManagedDir(platform = process.platform) {
+  return platform === "darwin" ? "/Library/Application Support/ClaudeCode" : platform === "win32" ? "C:\\Program Files\\ClaudeCode" : "/etc/claude-code";
+}
+function claudeConfigDir(env) {
+  return env.CLAUDE_CONFIG_DIR || join(env.HOME || homedir(), ".claude");
+}
+function claudeManagedFiles(env, managedDir = claudeManagedDir()) {
+  const dropInDir = join(managedDir, "managed-settings.d");
+  let dropIns = [];
+  try {
+    dropIns = readdirSync(dropInDir).filter((n) => n.endsWith(".json") && !n.startsWith(".")).sort().map((n) => join(dropInDir, n));
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT" && code !== "ENOTDIR") dropIns = [dropInDir];
+  }
+  return [
+    join(managedDir, "managed-settings.json"),
+    ...dropIns,
+    join(claudeConfigDir(env), "remote-settings.json")
+  ];
+}
+function claudeSettingsFiles(projectDir, env) {
   return [
-    managed,
-    join(configDir, "settings.json"),
+    join(claudeConfigDir(env), "settings.json"),
     join(projectDir, ".claude", "settings.json"),
     join(projectDir, ".claude", "settings.local.json")
   ];
@@ -197,24 +231,154 @@ function claudeGuardedBashRules(files) {
       if (code !== "ENOENT" && code !== "ENOTDIR") unreadable ??= file;
       continue;
     }
-    const permissions = isRecord(raw) ? raw.permissions : void 0;
-    if (!isRecord(permissions)) continue;
-    for (const key of ["deny", "ask"]) {
+    patterns.push(...bashRulePatterns(raw, ["deny", "ask"], 4));
+  }
+  return { patterns, unreadable };
+}
+function bashRulePatterns(doc, keys, depth = 0) {
+  if (!isRecord(doc)) return [];
+  const out = [];
+  const permissions = doc.permissions;
+  if (isRecord(permissions)) {
+    for (const key of keys) {
       const rules = permissions[key];
       if (!Array.isArray(rules)) continue;
       for (const rule of rules) {
         if (typeof rule !== "string") continue;
         const trimmed = rule.trim();
         if (trimmed === "Bash") {
-          patterns.push("*");
+          out.push("*");
           continue;
         }
         const match = /^Bash\((.*)\)$/s.exec(trimmed);
-        if (match?.[1] !== void 0) patterns.push(match[1]);
+        if (match?.[1] !== void 0) out.push(match[1]);
       }
     }
   }
-  return { patterns, unreadable };
+  if (depth > 0) {
+    for (const [key, value] of Object.entries(doc)) {
+      if (key !== "permissions") out.push(...bashRulePatterns(value, keys, depth - 1));
+    }
+  }
+  return out;
+}
+function setsTrue(doc, key, depth) {
+  if (!isRecord(doc)) return false;
+  if (doc[key] === true) return true;
+  return depth > 0 && Object.values(doc).some((v) => setsTrue(v, key, depth - 1));
+}
+var CLAUDE_RULE_FLAGS = /(?:^|\s)--(?:disallowedTools|disallowed-tools|settings|setting-sources)(?=[=\s]|$)/;
+var ANCESTOR_DEPTH = 8;
+function ancestorCommandText() {
+  const chain = [];
+  let pid = process.ppid;
+  if (process.platform === "linux") {
+    const lines = [];
+    for (let d = 0; d < ANCESTOR_DEPTH && pid > 1; d++) {
+      try {
+        lines.push(readFileSync(`/proc/${pid}/cmdline`, "utf-8").split("\0").join(" "));
+        const stat = readFileSync(`/proc/${pid}/stat`, "utf-8");
+        pid = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1]);
+      } catch {
+        return null;
+      }
+    }
+    return lines.join("\n");
+  }
+  const ps = (args) => {
+    try {
+      return execFileSync("ps", args, {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 5e3,
+        maxBuffer: 32 * 1024 * 1024
+      });
+    } catch {
+      return null;
+    }
+  };
+  const table = ps(["-A", "-o", "pid=,ppid="]);
+  if (table === null) return null;
+  const parent = /* @__PURE__ */ new Map();
+  for (const line of table.split("\n")) {
+    const m = /^\s*(\d+)\s+(\d+)\s*$/.exec(line);
+    if (m?.[1] && m[2]) parent.set(Number(m[1]), Number(m[2]));
+  }
+  for (let d = 0; d < ANCESTOR_DEPTH && pid > 1; d++) {
+    chain.push(pid);
+    const next = parent.get(pid);
+    if (next === void 0) break;
+    pid = next;
+  }
+  if (chain.length === 0) return null;
+  return ps(["-ww", "-o", "args=", "-p", chain.join(",")]);
+}
+function claudeAllowContext(projectDir, env) {
+  const user = env.USER || env.LOGNAME;
+  const profileDir = "/Library/Managed Preferences";
+  const profiles = process.platform === "darwin" ? [
+    join(profileDir, "com.anthropic.claudecode.plist"),
+    ...user ? [join(profileDir, user, "com.anthropic.claudecode.plist")] : []
+  ].filter((f) => existsSync(f)) : [];
+  return {
+    managedFiles: claudeManagedFiles(env),
+    profiles,
+    settingsFiles: claudeSettingsFiles(projectDir, env),
+    ancestors: ancestorCommandText(),
+    platform: process.platform
+  };
+}
+function claudeAllowedBashRules(ctx, env) {
+  const untrusted = (reason) => ({ trusted: false, reason });
+  if (ctx.platform === "win32") {
+    return untrusted(
+      "managed policy on Windows lives in the registry, which the hook does not read"
+    );
+  }
+  if (env.CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST) {
+    return untrusted("a host application supplies managed settings");
+  }
+  if (env.CLAUDE_CODE_ENTRYPOINT?.startsWith("sdk")) {
+    return untrusted("an Agent SDK session chooses its own settings sources");
+  }
+  if (ctx.profiles.length > 0) {
+    return untrusted(
+      `a managed configuration profile (${ctx.profiles[0]}) may restrict permission rules`
+    );
+  }
+  for (const file of ctx.managedFiles) {
+    let doc;
+    try {
+      doc = JSON.parse(readFileSync(file, "utf-8"));
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT" || code === "ENOTDIR") continue;
+      return untrusted(`managed settings ${file} cannot be read or parsed`);
+    }
+    if (setsTrue(doc, "allowManagedPermissionRulesOnly", 4)) {
+      return untrusted("managed settings make managed permission rules the only ones that apply");
+    }
+  }
+  if (ctx.ancestors === null) {
+    return untrusted(
+      "the Claude Code command line cannot be read for --disallowedTools or --settings"
+    );
+  }
+  if (CLAUDE_RULE_FLAGS.test(ctx.ancestors)) {
+    return untrusted(
+      "Claude Code was started with --disallowedTools, --settings or --setting-sources, whose rules the hook cannot read"
+    );
+  }
+  const patterns = [];
+  for (const file of ctx.settingsFiles) {
+    try {
+      patterns.push(
+        ...bashRulePatterns(JSON.parse(readFileSync(file, "utf-8")), ["allow"])
+      );
+    } catch {
+    }
+  }
+  return { trusted: true, patterns };
 }
 function codexGuardedWords(projectDir, env) {
   const home = env.CODEX_HOME || join(env.HOME || homedir(), ".codex");
@@ -241,16 +405,23 @@ function codexGuardedWords(projectDir, env) {
   }
   return out;
 }
-function guardedHeavyCommand(provider, segments, projectDir, env, files = claudeRuleFiles(projectDir, env)) {
+function guardedHeavyCommand(provider, segments, projectDir, env, files = claudeRuleFiles(projectDir, env), matches) {
   let rules;
   if (provider === "claude-code") {
     const found = claudeGuardedBashRules(files);
     if (found.unreadable !== null) return { kind: "unreadable", file: found.unreadable };
     rules = found.patterns.map(ruleWords);
     if (rules.some((words) => words.length === 0)) return { kind: "all" };
+    const governed = segments.map(
+      (s) => s.governed.slice(Math.max(0, s.governed.indexOf("cleo run ")))
+    );
+    if (matches && found.patterns.some((p) => governed.some((text) => matches(p, text)))) {
+      return { kind: "governed" };
+    }
   } else if (provider === "codex") {
     const words = codexGuardedWords(projectDir, env);
     rules = words.length === 0 ? [] : [words];
+    if (words.includes("cleo")) return { kind: "governed" };
   } else {
     return null;
   }
@@ -274,7 +445,7 @@ function guardedHeavyCommand(provider, segments, projectDir, env, files = claude
 function providerProjectDir(provider, env) {
   return provider === "claude-code" ? env.CLAUDE_PROJECT_DIR || void 0 : void 0;
 }
-async function heavyCommandHook(provider, stdin, io) {
+async function heavyCommandHook(provider, stdin, io, deps = {}) {
   const envMode = io.env.CLEO_HEAVY_COMMAND_HOOK?.trim().toLowerCase();
   if (envMode === "off") return "";
   const input = parseHookInput(stdin);
@@ -300,20 +471,51 @@ async function heavyCommandHook(provider, stdin, io) {
     );
   }
   if (!core.executableOnPath("cleo", io.env.PATH)) plan = demote(plan, "`cleo` is not on PATH");
-  if (provider !== "kimi" && !REWRITE_MODES.has(input.permission_mode ?? "")) {
+  const permissionMode = input.permission_mode ?? "";
+  let preApproved = false;
+  if (plan.action === "rewrite" && provider === "claude-code" && PRE_APPROVE_MODES.has(permissionMode)) {
+    const projectDir = io.env.CLAUDE_PROJECT_DIR;
+    const verdict = claudePreApprovalVerdict(
+      input.tool_input.command,
+      cwd,
+      io.env,
+      core,
+      projectDir && deps.allowContext ? deps.allowContext(projectDir, io.env) : void 0
+    );
+    preApproved = verdict.approved;
+    if (!verdict.approved && !REWRITE_MODES.has(permissionMode)) {
+      plan = demote(
+        plan,
+        `rewriting it would change which permission rules match it, so in ${permissionMode} mode the hook rewrites only a command your Claude Code allow rules already approve, and ${verdict.reason} (bypassPermissions or auto mode rewrite every heavy command)`
+      );
+    }
+  }
+  if (provider !== "kimi" && !preApproved && !REWRITE_MODES.has(permissionMode)) {
     plan = demote(
       plan,
       `rewriting it would change which permission rules match it, so the hook rewrites only in bypassPermissions or auto mode (this session: ${input.permission_mode ?? "unknown"})`
     );
   }
   if (plan.action === "rewrite") {
-    const hit = guardedHeavyCommand(provider, plan.segments, projectRoot, io.env);
+    const hit = guardedHeavyCommand(
+      provider,
+      plan.segments,
+      projectRoot,
+      io.env,
+      claudeRuleFiles(projectRoot, io.env),
+      core.claudeBashRuleMatches
+    );
     const where = provider === "codex" ? "Codex rules" : "Claude Code settings";
     if (hit?.kind === "word") {
       plan = demote(
         plan,
         `a deny or ask rule in your ${where} names \`${hit.word}\`, and a rewrite would hide the command from it`
       );
+    } else if (hit?.kind === "governed") {
+      plan = demote(
+        plan,
+        `a deny or ask rule in your ${where} matches \`cleo run\`, which the rewrite would run`
+      );
     } else if (hit?.kind === "all") {
       plan = demote(
         plan,
@@ -327,7 +529,22 @@ async function heavyCommandHook(provider, stdin, io) {
     }
   }
   const context = heavyHookContext(plan, await core.heavyPressureNotice(), provider);
-  return renderHeavyHookAnswer(provider, input.tool_input, plan, context, budget.timeoutMs);
+  return renderHeavyHookAnswer(
+    provider,
+    input.tool_input,
+    plan,
+    context,
+    budget.timeoutMs,
+    preApproved && plan.action === "rewrite"
+  );
+}
+function claudePreApprovalVerdict(command, cwd, env, core, ctx) {
+  const projectDir = env.CLAUDE_PROJECT_DIR;
+  if (!projectDir) return { approved: false, reason: "CLAUDE_PROJECT_DIR is not set" };
+  const rules = claudeAllowedBashRules(ctx ?? claudeAllowContext(projectDir, env), env);
+  if (!rules.trusted) return { approved: false, reason: rules.reason };
+  const verdict = core.claudePreApproval(command, rules.patterns, { cwd, workingDir: projectDir });
+  return verdict.approved ? verdict : { approved: false, reason: `it is not pre-approved: ${verdict.reason}` };
 }
 var USAGE = "usage: cleo hook heavy-command [--provider claude-code|codex|kimi|opencode] < hook-input.json\n";
 async function runHookCli(argv, io = processHookIo()) {
@@ -356,8 +573,16 @@ async function runHookCli(argv, io = processHookIo()) {
 }
 export {
   HEAVY_HOOK_PROVIDERS,
+  ancestorCommandText,
+  bashRulePatterns,
+  claudeAllowContext,
+  claudeAllowedBashRules,
   claudeGuardedBashRules,
+  claudeManagedDir,
+  claudeManagedFiles,
+  claudePreApprovalVerdict,
   claudeRuleFiles,
+  claudeSettingsFiles,
   codexGuardedWords,
   guardedHeavyCommand,
   heavyCommandHook,

package/dist/cli/hygiene-3QZ2NI7P.js

@@ -0,0 +1,55 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+
+// packages/cleo/src/cli/commands/hygiene.ts
+import { getProjectRoot } from "@cleocode/core";
+import { runSpawnReadinessHygieneCli } from "@cleocode/core/hygiene/validate-spawn-readiness.js";
+var hygieneCommand = defineCommand({
+  meta: {
+    name: "hygiene",
+    description: "Run spawn-readiness hygiene checks"
+  },
+  subCommands: {
+    "validate-spawn-readiness": defineCommand({
+      meta: {
+        name: "validate-spawn-readiness",
+        description: "Run all pre-spawn hygiene gates (changeset lint, changelog drift, worktree location)"
+      },
+      args: {
+        "project-root": {
+          type: "string",
+          description: "Project root directory (default: auto-detect)"
+        },
+        "worktree-path": {
+          type: "string",
+          description: "Expected worktree path for location validation"
+        }
+      },
+      async run({ args }) {
+        const projectRoot = args["project-root"] || getProjectRoot() || process.cwd();
+        const worktreePath = args["worktree-path"];
+        await runSpawnReadinessHygieneCli(projectRoot, worktreePath);
+      }
+    })
+  }
+});
+export {
+  hygieneCommand
+};
+//# sourceMappingURL=hygiene-3QZ2NI7P.js.map