@cleocode/cleo 2026.10.4 → 2026.10.5

package/dist/cli/chunk-NEFMQYLE.js

@@ -0,0 +1,656 @@
+(() => {
+  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 {
+  E_PLAYBOOK_RESUME_BLOCKED,
+  E_PLAYBOOK_RUNTIME_INVALID,
+  PlaybookParseError,
+  executePlaybook,
+  getPendingApprovals,
+  getPlaybookApprovalByToken,
+  getPlaybookRun,
+  listPlaybookApprovals,
+  listPlaybookRuns,
+  parsePlaybook,
+  resumePlaybook
+} from "./chunk-NU6CQQVB.js";
+import {
+  defineTypedHandler,
+  lafsError,
+  lafsSuccess,
+  typedDispatch
+} from "./chunk-QWNKLLLG.js";
+import {
+  dispatchMeta,
+  getListParams,
+  handleErrorResult,
+  unsupportedOp
+} from "./chunk-XHRZ7OYZ.js";
+
+// packages/cleo/src/dispatch/domains/playbook.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve as resolvePath } from "node:path";
+import {
+  listPlaybooks,
+  PlaybookNotFoundError,
+  resolvePlaybook
+} from "@cleocode/core/playbooks/playbook-resolver";
+var __playbookRuntimeOverrides = {};
+function normalizeListStatus(raw) {
+  if (typeof raw !== "string" || raw.length === 0) return void 0;
+  const value = raw.trim().toLowerCase();
+  switch (value) {
+    case "active":
+    case "running":
+      return "running";
+    case "pending":
+    case "paused":
+      return "paused";
+    case "completed":
+    case "done":
+      return "completed";
+    case "failed":
+      return "failed";
+    case "cancelled":
+    case "canceled":
+      return "cancelled";
+    default:
+      return void 0;
+  }
+}
+async function loadPlaybookByName(name) {
+  const candidates = __playbookRuntimeOverrides.playbookBaseDirs;
+  if (candidates) {
+    const fileName = name.endsWith(".cantbook") ? name : `${name}.cantbook`;
+    for (const dir of candidates) {
+      const full = join(dir, fileName);
+      if (existsSync(full)) {
+        return { sourcePath: full, source: readFileSync(full, "utf8") };
+      }
+    }
+    return null;
+  }
+  try {
+    const { getProjectRoot } = await import("@cleocode/core/project-scope");
+    const projectRoot = __playbookRuntimeOverrides.projectRoot ?? getProjectRoot();
+    const resolved = resolvePlaybook(name, {
+      projectRoot,
+      globalPlaybooksDir: __playbookRuntimeOverrides.globalPlaybooksDir,
+      packagedStarterDir: __playbookRuntimeOverrides.packagedStarterDir
+    });
+    return { sourcePath: resolved.path, source: resolved.source };
+  } catch (err) {
+    if (err instanceof PlaybookNotFoundError) return null;
+    return null;
+  }
+}
+function parseContextJson(raw) {
+  if (raw === void 0 || raw === null || raw === "") return {};
+  if (typeof raw === "object" && !Array.isArray(raw)) {
+    return raw;
+  }
+  if (typeof raw !== "string") {
+    throw new Error(`context must be a JSON object, got ${typeof raw}`);
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("context JSON must decode to an object");
+    }
+    return parsed;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`invalid context JSON: ${message}`);
+  }
+}
+async function acquireDb() {
+  if (__playbookRuntimeOverrides.db) return __playbookRuntimeOverrides.db;
+  const { getDb, getNativeDb } = await import("@cleocode/core/store/sqlite");
+  await getDb();
+  const native = getNativeDb();
+  if (!native) {
+    throw new Error("playbook dispatch: tasks.db singleton was not initialized by getDb()");
+  }
+  return native;
+}
+async function buildDefaultDispatcher() {
+  if (__playbookRuntimeOverrides.dispatcher) return __playbookRuntimeOverrides.dispatcher;
+  const { orchestrateSpawnExecute } = await import("@cleocode/runtime/gateway");
+  const [
+    { getProjectRoot },
+    { createToolGuard },
+    { runSkillNodeOrSpawn },
+    { maybeCreatePiRunner },
+    { resolveCantbookNodeProfile, hasCantbookProfilePin },
+    { DEFAULT_DETERMINISTIC_DENIED_COMMANDS }
+  ] = await Promise.all([
+    import("@cleocode/core/project-scope"),
+    import("@cleocode/core/tools/guard"),
+    import("@cleocode/core/playbooks/skill-node-executor"),
+    import("@cleocode/core/playbooks/pi-runner-wiring"),
+    import("@cleocode/core/playbooks/cantbook-profile"),
+    import("@cleocode/core/playbooks/guarded-deterministic-runner")
+  ]);
+  const projectRoot = getProjectRoot();
+  const tools = createToolGuard({
+    allowedRoots: [projectRoot],
+    deniedCommands: DEFAULT_DETERMINISTIC_DENIED_COMMANDS,
+    mode: "enforce"
+  });
+  const runner = await maybeCreatePiRunner({ system: "task-executor", projectRoot });
+  const resolveStageProfile = async (input) => {
+    if (!hasCantbookProfilePin({
+      profile: input.profile,
+      model: input.model,
+      provider: input.provider
+    })) {
+      return void 0;
+    }
+    const resolved = await resolveCantbookNodeProfile({
+      playbookName: input.playbookName ?? "cantbook",
+      nodeId: input.nodeId,
+      pin: { profile: input.profile, model: input.model, provider: input.provider },
+      projectRoot
+    });
+    return {
+      [`${input.nodeId}_llm`]: {
+        provider: resolved.provider,
+        model: resolved.model,
+        source: resolved.source,
+        profile: input.profile ?? null
+      }
+    };
+  };
+  const spawn = async (input) => {
+    const result = await orchestrateSpawnExecute(
+      input.taskId,
+      /* adapterId */
+      void 0,
+      /* protocolType */
+      void 0,
+      projectRoot,
+      /* tier */
+      void 0
+    );
+    if (result.success) {
+      return {
+        status: "success",
+        output: {
+          [`${input.nodeId}_spawn`]: true,
+          nodeId: input.nodeId,
+          agentId: input.agentId,
+          dispatchData: result.data ?? null
+        }
+      };
+    }
+    return {
+      status: "failure",
+      output: {},
+      error: result.error?.message ?? `spawn failed for ${input.agentId}`
+    };
+  };
+  return {
+    async dispatch(input) {
+      try {
+        const llmHint = await resolveStageProfile(input);
+        const result = await runSkillNodeOrSpawn(
+          { nodeId: input.nodeId, agentId: input.agentId, context: input.context },
+          {
+            tools,
+            cwd: projectRoot,
+            subprocessSpawn: () => spawn(input),
+            ...runner !== void 0 ? { runner } : {}
+          }
+        );
+        if (llmHint !== void 0 && result.status === "success") {
+          return { ...result, output: { ...result.output, ...llmHint } };
+        }
+        return result;
+      } catch (err) {
+        return {
+          status: "failure",
+          output: {},
+          error: err instanceof Error ? err.message : String(err)
+        };
+      }
+    }
+  };
+}
+async function buildDefaultDeterministicRunner() {
+  if (__playbookRuntimeOverrides.deterministicRunner) {
+    return __playbookRuntimeOverrides.deterministicRunner;
+  }
+  if (__playbookRuntimeOverrides.dispatcher) {
+    return void 0;
+  }
+  const [
+    { getProjectRoot },
+    { createToolGuard },
+    { createGuardedDeterministicRunner, DEFAULT_DETERMINISTIC_DENIED_COMMANDS }
+  ] = await Promise.all([
+    import("@cleocode/core/project-scope"),
+    import("@cleocode/core/tools/guard"),
+    import("@cleocode/core/playbooks/guarded-deterministic-runner")
+  ]);
+  const projectRoot = getProjectRoot();
+  const tools = createToolGuard({
+    allowedRoots: [projectRoot],
+    deniedCommands: DEFAULT_DETERMINISTIC_DENIED_COMMANDS,
+    mode: "enforce"
+  });
+  return createGuardedDeterministicRunner({ tools });
+}
+function toRunEnvelope(result) {
+  const envelope = {
+    runId: result.runId,
+    terminalStatus: result.terminalStatus,
+    finalContext: result.finalContext
+  };
+  if (result.approvalToken !== void 0) envelope.approvalToken = result.approvalToken;
+  if (result.failedNodeId !== void 0) envelope.failedNodeId = result.failedNodeId;
+  if (result.exceededNodeId !== void 0) envelope.exceededNodeId = result.exceededNodeId;
+  if (result.errorContext !== void 0) envelope.errorContext = result.errorContext;
+  return envelope;
+}
+var _playbookTypedHandler = defineTypedHandler("playbook", {
+  // -----------------------------------------------------------------------
+  // Query ops
+  // -----------------------------------------------------------------------
+  status: async (params) => {
+    const runId = params.runId;
+    if (!runId) {
+      return lafsError("E_INVALID_INPUT", "runId is required", "status");
+    }
+    const db = await acquireDb();
+    const run = getPlaybookRun(db, runId);
+    if (run === null) {
+      return lafsError("E_NOT_FOUND", `playbook run ${runId} not found`, "status");
+    }
+    return lafsSuccess(run, "status");
+  },
+  // SSoT-EXEMPT:db-injection+runtime-offset-pagination — listPlaybookRunsState only
+  // supports LIMIT; offset must be applied client-side after fetch. acquireDb() returns
+  // a DatabaseSync handle that cannot be represented as a wire-format param (ADR-057 D1).
+  list: async (params) => {
+    const statusFilter = normalizeListStatus(params.status);
+    const epicId = typeof params.epicId === "string" ? params.epicId : void 0;
+    const { limit, offset } = getListParams(params);
+    const db = await acquireDb();
+    const opts = {};
+    if (statusFilter !== void 0) opts.status = statusFilter;
+    if (epicId !== void 0) opts.epicId = epicId;
+    if (typeof limit === "number") opts.limit = limit;
+    const runs = listPlaybookRuns(db, opts);
+    const paged = typeof offset === "number" ? runs.slice(offset) : runs;
+    const envelope = {
+      runs: paged,
+      count: paged.length,
+      total: runs.length
+    };
+    if (statusFilter !== void 0) envelope.statusFilter = statusFilter;
+    return lafsSuccess(envelope, "list");
+  },
+  // SSoT-EXEMPT:file-load+parse — must resolve .cantbook from disk before any DB row
+  // is written; parsePlaybook returns a non-wire-serializable definition object
+  // (ADR-057 D1 exception).
+  validate: async (params) => {
+    const file = params.file;
+    const name = params.name;
+    if (!file && !name) {
+      return lafsError(
+        "E_INVALID_INPUT",
+        "Either file (path) or name (playbook name) is required",
+        "validate"
+      );
+    }
+    let source;
+    let sourcePath;
+    if (file) {
+      const resolved = resolvePath(file);
+      if (!existsSync(resolved)) {
+        return lafsError("E_NOT_FOUND", `playbook file not found: ${resolved}`, "validate");
+      }
+      sourcePath = resolved;
+      source = readFileSync(resolved, "utf8");
+    } else {
+      const loaded = await loadPlaybookByName(name);
+      if (loaded === null) {
+        return lafsError(
+          "E_NOT_FOUND",
+          `playbook "${name}" not found in any search path`,
+          "validate"
+        );
+      }
+      sourcePath = loaded.sourcePath;
+      source = loaded.source;
+    }
+    try {
+      const { definition, sourceHash } = parsePlaybook(source);
+      return lafsSuccess(
+        {
+          valid: true,
+          sourcePath,
+          sourceHash,
+          name: definition.name,
+          version: definition.version,
+          nodeCount: definition.nodes.length,
+          edgeCount: definition.edges.length,
+          hasRequires: definition.nodes.some((n) => n.requires !== void 0),
+          hasEnsures: definition.nodes.some((n) => n.ensures !== void 0),
+          hasErrorHandlers: (definition.error_handlers?.length ?? 0) > 0
+        },
+        "validate"
+      );
+    } catch (err) {
+      if (err instanceof PlaybookParseError) {
+        return lafsError(
+          err.code,
+          `${err.message}${err.field ? ` [field=${err.field}]` : ""}`,
+          "validate"
+        );
+      }
+      return lafsError(
+        "E_PLAYBOOK_PARSE",
+        err instanceof Error ? err.message : String(err),
+        "validate"
+      );
+    }
+  },
+  // SSoT-EXEMPT:filesystem-resolver — listPlaybooks() reads .cantbook files from the
+  // filesystem across three tiers (project / global / packaged). projectRoot comes
+  // from @cleocode/core/internal which is non-wire-serializable infrastructure (ADR-057 D1).
+  catalog: async (params) => {
+    const tierFilter = params.tier ?? "all";
+    let projectRoot;
+    if (tierFilter === "all" || tierFilter === "project") {
+      if (__playbookRuntimeOverrides.projectRoot) {
+        projectRoot = __playbookRuntimeOverrides.projectRoot;
+      } else {
+        try {
+          const { getProjectRoot } = await import("@cleocode/core/project-scope");
+          projectRoot = getProjectRoot();
+        } catch {
+          projectRoot = void 0;
+        }
+      }
+    }
+    const allEntries = listPlaybooks({
+      projectRoot,
+      globalPlaybooksDir: __playbookRuntimeOverrides.globalPlaybooksDir,
+      packagedStarterDir: __playbookRuntimeOverrides.packagedStarterDir
+    });
+    const filtered = tierFilter === "all" ? allEntries : allEntries.filter((entry) => entry.tier === tierFilter);
+    return lafsSuccess(
+      {
+        playbooks: filtered.map((entry) => ({
+          name: entry.name,
+          tier: entry.tier,
+          path: entry.path
+        })),
+        count: filtered.length,
+        tierFilter
+      },
+      "catalog"
+    );
+  },
+  // -----------------------------------------------------------------------
+  // Mutate ops
+  // -----------------------------------------------------------------------
+  // SSoT-EXEMPT:db-injection+file-load+executePlaybook — db is a DatabaseSync handle
+  // (non-wire-serializable infrastructure per ADR-057 D1); file loading and
+  // parsePlaybook return a non-wire-serializable PlaybookDefinition; executePlaybook
+  // is the runtime state machine SSoT in @cleocode/playbooks and must remain here.
+  run: async (params) => {
+    const name = params.name;
+    if (!name) {
+      return lafsError("E_INVALID_INPUT", "name is required", "run");
+    }
+    let initialContext;
+    try {
+      initialContext = parseContextJson(params.context);
+    } catch (err) {
+      return lafsError("E_INVALID_INPUT", err instanceof Error ? err.message : String(err), "run");
+    }
+    const loaded = await loadPlaybookByName(name);
+    if (loaded === null) {
+      return lafsError("E_NOT_FOUND", `playbook "${name}" not found in any search path`, "run");
+    }
+    let parsed;
+    try {
+      parsed = parsePlaybook(loaded.source);
+    } catch (err) {
+      if (err instanceof PlaybookParseError) {
+        return lafsError(
+          err.code,
+          `${err.message}${err.field ? ` [field=${err.field}]` : ""}`,
+          "run"
+        );
+      }
+      return lafsError("E_PLAYBOOK_PARSE", err instanceof Error ? err.message : String(err), "run");
+    }
+    const db = await acquireDb();
+    const dispatcher = await buildDefaultDispatcher();
+    const deterministicRunner = await buildDefaultDeterministicRunner();
+    let result;
+    try {
+      const { getProjectRoot } = await import("@cleocode/core/project-scope");
+      const opts = {
+        db,
+        playbook: parsed.definition,
+        playbookHash: parsed.sourceHash,
+        initialContext,
+        dispatcher,
+        projectRoot: getProjectRoot()
+      };
+      if (deterministicRunner !== void 0) opts.deterministicRunner = deterministicRunner;
+      if (__playbookRuntimeOverrides.approvalSecret !== void 0) {
+        opts.approvalSecret = __playbookRuntimeOverrides.approvalSecret;
+      }
+      const epicIdRaw = initialContext["epicId"];
+      if (typeof epicIdRaw === "string") opts.epicId = epicIdRaw;
+      const sessionIdRaw = initialContext["sessionId"];
+      if (typeof sessionIdRaw === "string") opts.sessionId = sessionIdRaw;
+      result = await executePlaybook(opts);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const code = message.startsWith(E_PLAYBOOK_RUNTIME_INVALID) ? E_PLAYBOOK_RUNTIME_INVALID : "E_PLAYBOOK_RUNTIME";
+      return lafsError(code, message, "run");
+    }
+    return lafsSuccess(
+      {
+        ...toRunEnvelope(result),
+        playbookName: parsed.definition.name,
+        playbookSource: loaded.sourcePath
+      },
+      "run"
+    );
+  },
+  // SSoT-EXEMPT:db-injection+gate-validation — db is a DatabaseSync handle (ADR-057 D1);
+  // approval gate state machine requires loading playbook source + verifying hash
+  // integrity; resumePlaybook is the runtime SSoT in @cleocode/playbooks.
+  resume: async (params) => {
+    const runId = params.runId;
+    if (!runId) {
+      return lafsError("E_INVALID_INPUT", "runId is required", "resume");
+    }
+    const db = await acquireDb();
+    const run = getPlaybookRun(db, runId);
+    if (run === null) {
+      return lafsError("E_NOT_FOUND", `playbook run ${runId} not found`, "resume");
+    }
+    const approvals = loadApprovalsForRun(db, runId);
+    if (approvals.length === 0) {
+      return lafsError(
+        "E_APPROVAL_NOT_FOUND",
+        `run ${runId} has no approval gates \u2014 nothing to resume`,
+        "resume"
+      );
+    }
+    const latest = approvals[approvals.length - 1];
+    if (latest.status === "pending") {
+      return lafsError(
+        "E_APPROVAL_PENDING",
+        `gate ${latest.approvalId} for run ${runId} is still pending \u2014 approve before resuming`,
+        "resume"
+      );
+    }
+    if (latest.status === "rejected") {
+      return lafsError(
+        "E_APPROVAL_REJECTED",
+        `gate ${latest.approvalId} was rejected${latest.reason ? ` (${latest.reason})` : ""}`,
+        "resume"
+      );
+    }
+    const loaded = await loadPlaybookByName(run.playbookName);
+    if (loaded === null) {
+      return lafsError(
+        "E_NOT_FOUND",
+        `playbook "${run.playbookName}" not found \u2014 cannot resume run ${runId}`,
+        "resume"
+      );
+    }
+    let parsed;
+    try {
+      parsed = parsePlaybook(loaded.source);
+    } catch (err) {
+      return lafsError(
+        "E_PLAYBOOK_PARSE",
+        err instanceof Error ? err.message : String(err),
+        "resume"
+      );
+    }
+    if (parsed.sourceHash !== run.playbookHash) {
+      return lafsError(
+        "E_PLAYBOOK_HASH_MISMATCH",
+        `playbook "${run.playbookName}" source changed since run started (hash drift)`,
+        "resume"
+      );
+    }
+    const dispatcher = await buildDefaultDispatcher();
+    const deterministicRunner = await buildDefaultDeterministicRunner();
+    try {
+      const opts = {
+        db,
+        playbook: parsed.definition,
+        approvalToken: latest.token,
+        dispatcher
+      };
+      if (deterministicRunner !== void 0) opts.deterministicRunner = deterministicRunner;
+      if (__playbookRuntimeOverrides.approvalSecret !== void 0) {
+        opts.approvalSecret = __playbookRuntimeOverrides.approvalSecret;
+      }
+      const result = await resumePlaybook(opts);
+      return lafsSuccess(toRunEnvelope(result), "resume");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (message.startsWith(E_PLAYBOOK_RESUME_BLOCKED)) {
+        return lafsError(E_PLAYBOOK_RESUME_BLOCKED, message, "resume");
+      }
+      return lafsError("E_PLAYBOOK_RUNTIME", message, "resume");
+    }
+  }
+});
+var QUERY_OPS = /* @__PURE__ */ new Set(["status", "list", "validate", "catalog"]);
+var MUTATE_OPS = /* @__PURE__ */ new Set(["run", "resume"]);
+var PlaybookHandler = class {
+  /**
+   * Query gateway — `status`, `list`, and `validate`.
+   */
+  async query(operation, params) {
+    const startTime = Date.now();
+    if (!QUERY_OPS.has(operation)) {
+      return unsupportedOp("query", "playbook", operation, startTime);
+    }
+    try {
+      const envelope = await typedDispatch(
+        _playbookTypedHandler,
+        operation,
+        params ?? {}
+      );
+      return {
+        meta: dispatchMeta("query", "playbook", operation, startTime),
+        success: envelope.success,
+        ...envelope.success ? { data: envelope.data } : {
+          error: {
+            code: envelope.error?.code !== void 0 ? String(envelope.error.code) : "E_INTERNAL",
+            message: envelope.error?.message ?? "Unknown error"
+          }
+        }
+      };
+    } catch (err) {
+      return handleErrorResult("query", "playbook", operation, err, startTime);
+    }
+  }
+  /**
+   * Mutate gateway — `run` and `resume`.
+   */
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    if (!MUTATE_OPS.has(operation)) {
+      return unsupportedOp("mutate", "playbook", operation, startTime);
+    }
+    try {
+      const envelope = await typedDispatch(
+        _playbookTypedHandler,
+        operation,
+        params ?? {}
+      );
+      return {
+        meta: dispatchMeta("mutate", "playbook", operation, startTime),
+        success: envelope.success,
+        ...envelope.success ? { data: envelope.data } : {
+          error: {
+            code: envelope.error?.code !== void 0 ? String(envelope.error.code) : "E_INTERNAL",
+            message: envelope.error?.message ?? "Unknown error"
+          }
+        }
+      };
+    } catch (err) {
+      return handleErrorResult("mutate", "playbook", operation, err, startTime);
+    }
+  }
+  /**
+   * Exposed operations for dispatcher introspection + parity tests.
+   */
+  getSupportedOperations() {
+    return {
+      query: ["catalog", "list", "status", "validate"],
+      mutate: ["run", "resume"]
+    };
+  }
+};
+function loadApprovalsForRun(db, runId) {
+  return listPlaybookApprovals(db, runId);
+}
+async function acquirePlaybookDb() {
+  return acquireDb();
+}
+async function listPendingApprovalsForDispatch() {
+  const db = await acquireDb();
+  return getPendingApprovals(db);
+}
+async function lookupApprovalByTokenForDispatch(token) {
+  const db = await acquireDb();
+  return getPlaybookApprovalByToken(db, token);
+}
+
+export {
+  __playbookRuntimeOverrides,
+  PlaybookHandler,
+  acquirePlaybookDb,
+  listPendingApprovalsForDispatch,
+  lookupApprovalByTokenForDispatch
+};
+//# sourceMappingURL=chunk-NEFMQYLE.js.map

package/dist/cli/{chunk-QFFQSKRC.js → chunk-NU6CQQVB.js}

@@ -3497,7 +3497,11 @@ function evaluatePolicy(command, rules = DEFAULT_POLICY_RULES) {
 // packages/playbooks/src/runtime.ts
 import { appendFileSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { defaultVariableResolver, getEnsuresSchema, listEnsuresSchemaNames } from "@cleocode/core";
+import { defaultResolver as defaultVariableResolver } from "@cleocode/core/agents/variable-substitution";
+import {
+  getEnsuresSchema,
+  listEnsuresSchemaNames
+} from "@cleocode/core/dispatch/contracts/ensures-schema";
 
 // packages/playbooks/src/state.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -4494,4 +4498,4 @@ export {
 js-yaml/dist/js-yaml.mjs:
   (*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT *)
 */
-//# sourceMappingURL=chunk-QFFQSKRC.js.map
+//# sourceMappingURL=chunk-NU6CQQVB.js.map

package/dist/cli/{chunk-5J2VH3BC.js → chunk-PN4WW5VX.js}

@@ -18,15 +18,15 @@ import {
 } from "./chunk-PKKZPOOP.js";
 import {
   cliOutput
-} from "./chunk-3ZO3M37V.js";
+} from "./chunk-4RGSNUUP.js";
 
 // packages/cleo/src/cli/commands/doctor-project-identity.ts
-import { getProjectRoot } from "@cleocode/core";
 import {
   inspectProjectIdentity,
   inspectProjectNameDrift,
   resolveProjectIdentity
 } from "@cleocode/core/doctor/project-identity.js";
+import { getProjectRoot } from "@cleocode/core/project-scope";
 var doctorProjectIdentityCommand = defineCommand({
   meta: {
     name: "project-identity",
@@ -63,4 +63,4 @@ var doctorProjectIdentityCommand = defineCommand({
 export {
   doctorProjectIdentityCommand
 };
-//# sourceMappingURL=chunk-5J2VH3BC.js.map
+//# sourceMappingURL=chunk-PN4WW5VX.js.map