@cleocode/cleo 2026.10.3 → 2026.10.5-rc.ci.672

package/dist/cli/federation-ESM35EGG.js

@@ -0,0 +1,145 @@
+(() => {
+  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 {
+  cliError,
+  cliOutput,
+  humanLine
+} from "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/federation.ts
+import { ExitCode } from "@cleocode/contracts/exit-codes.js";
+import { skills } from "@cleocode/core";
+var { addFederationPeer, listFederationPeers, removeFederationPeer } = skills;
+var addCommand = defineCommand({
+  meta: {
+    name: "add",
+    description: "Add (or update) a federation peer in ~/.cleo/federation.json"
+  },
+  args: {
+    url: {
+      type: "positional",
+      description: "Peer URL (must use http:// or https://)",
+      required: true
+    },
+    trust: {
+      type: "string",
+      description: "Trust level: verified | unverified | blocked (default: unverified)",
+      default: "unverified"
+    }
+  },
+  async run({ args }) {
+    try {
+      const trust = String(args.trust);
+      const result = addFederationPeer(String(args.url), trust);
+      cliOutput(
+        {
+          entry: result.entry,
+          updated: result.updated
+        },
+        { command: "federation add", operation: "federation.add" }
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`federation add failed: ${message}`, ExitCode.VALIDATION_ERROR);
+    }
+  }
+});
+var removeCommand = defineCommand({
+  meta: {
+    name: "remove",
+    description: "Remove a federation peer from ~/.cleo/federation.json"
+  },
+  args: {
+    url: {
+      type: "positional",
+      description: "Peer URL to remove (normalised before lookup)",
+      required: true
+    }
+  },
+  async run({ args }) {
+    try {
+      const removed = removeFederationPeer(String(args.url));
+      cliOutput(
+        { url: String(args.url), removed },
+        { command: "federation remove", operation: "federation.remove" }
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`federation remove failed: ${message}`, ExitCode.VALIDATION_ERROR);
+    }
+  }
+});
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List all federation peers in ~/.cleo/federation.json"
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Emit raw JSON envelope instead of human-readable list",
+      default: false
+    }
+  },
+  async run({ args }) {
+    try {
+      const entries = listFederationPeers();
+      if (args.json) {
+        cliOutput(
+          { count: entries.length, entries },
+          { command: "federation list", operation: "federation.list" }
+        );
+        return;
+      }
+      if (entries.length === 0) {
+        humanLine("(no federation peers configured)");
+        return;
+      }
+      for (const entry of entries) {
+        humanLine(`${entry.trust.padEnd(11)}  ${entry.url}  (added ${entry.addedAt})`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`federation list failed: ${message}`, ExitCode.GENERAL_ERROR);
+    }
+  }
+});
+var federationCommand = defineCommand({
+  meta: {
+    name: "federation",
+    description: "Federation peer management: add, remove, list trusted peers"
+  },
+  subCommands: {
+    add: addCommand,
+    remove: removeCommand,
+    list: listCommand
+  },
+  run({ rawArgs }) {
+    const sub = rawArgs?.find((a) => !a.startsWith("-"));
+    if (!sub) {
+      showUsage(federationCommand);
+    }
+  }
+});
+export {
+  federationCommand
+};
+//# sourceMappingURL=federation-ESM35EGG.js.map

package/dist/cli/find-5EUZHHQJ.js

@@ -0,0 +1,178 @@
+(() => {
+  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 {
+  dispatchRaw,
+  handleRawError,
+  maybeEmitDescribe
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import {
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/find.ts
+import { ExitCode } from "@cleocode/contracts/exit-codes.js";
+import { createPage } from "@cleocode/core/pagination";
+var findCommand = defineCommand({
+  meta: { name: "find", description: "Lexical task search; fuzzy matching requires --fuzzy" },
+  args: {
+    query: {
+      type: "positional",
+      description: "Search text (required unless --id is provided)",
+      required: false
+    },
+    id: { type: "string", description: "Search by ID prefix" },
+    exact: { type: "boolean", description: "Exact title match" },
+    fuzzy: {
+      type: "boolean",
+      description: "Opt into character-subsequence matches; each result explains its matching fields"
+    },
+    status: {
+      type: "string",
+      description: "Filter by status (pending|active|blocked|done|cancelled)"
+    },
+    in: { type: "string", description: "Field to search in (title|description|notes|id)" },
+    "include-archive": { type: "boolean", description: "Include archived tasks" },
+    limit: {
+      type: "string",
+      description: "Max results (default: 20; --limit 0 returns every match)"
+    },
+    // GH #1302 — parity with `cleo list --all`. `find` truncated at 20 with no
+    // way to enumerate: no such flag existed, and `--limit 0` returned zero
+    // rows rather than everything. The truncation warning could therefore name
+    // a remedy this command did not have.
+    all: {
+      type: "boolean",
+      description: "Return EVERY matching task instead of the default page of 20."
+    },
+    offset: { type: "string", description: "Skip first N results" },
+    fields: { type: "string", description: "Comma-separated additional fields to include" },
+    verbose: {
+      type: "boolean",
+      description: "Return full task records instead of the MVI projection (id + title + status + key metadata). T9922.",
+      alias: "v"
+    },
+    // T9922 — MVI record projection opt-out alias (surfaced for --help).
+    full: {
+      type: "boolean",
+      description: "Alias for --verbose. T9922."
+    },
+    /**
+     * Filter by task kind axis (T944/T9072).
+     * Values: work | research | experiment | bug | spike | release
+     */
+    kind: {
+      type: "string",
+      description: "Filter by kind axis (work|research|experiment|bug|spike|release) \u2014 T944"
+    },
+    /**
+     * Unified urgency surface (T9905).
+     *
+     * Selects tasks where
+     *   priority IN ('critical','high') OR severity IN ('P0','P1')
+     *
+     * Combines the two orthogonal urgency axes (priority + severity) into a
+     * single filter so agents don't have to query each axis separately.
+     */
+    urgent: {
+      type: "boolean",
+      description: "Surface urgent work across both axes: priority IN (critical,high) OR severity IN (P0,P1) (T9905)",
+      alias: "u"
+    },
+    /**
+     * Filter by label — `cleo find --label <name>` returns every task
+     * whose `labels[]` includes the given value. Closes GH#393 and gives
+     * `find` parity with the positional `cleo labels <name>` surface.
+     * @task T9904
+     */
+    label: {
+      type: "string",
+      description: "Filter by label \u2014 return tasks whose labels[] includes this value (T9904)"
+    },
+    /**
+     * Filter by parent task ID — `cleo find --parent <id>` returns only
+     * tasks whose `parentId` matches. Mirrors the `--parent` axis on
+     * `cleo list`. When the parent target is a Saga (Epic with
+     * `label='saga'`), routing goes through `task_relations.type='groups'`
+     * member IDs (ADR-073 §1) — same path as `cleo list --parent`.
+     *
+     * Closes T10108 — pre-fix the flag was missing entirely AND empty-string
+     * queries bypassed every filter via `fuzzyScore('', '<title>')===80`.
+     *
+     * @task T10108
+     * @saga T9862
+     */
+    parent: {
+      type: "string",
+      description: "Filter by direct parentId containment, including saga children"
+    }
+  },
+  async run({ args }) {
+    if (maybeEmitDescribe("query", "tasks", "find", { command: "find" })) return;
+    let limit = args.limit !== void 0 ? Number(args.limit) : void 0;
+    if (args.all === true) limit = 0;
+    const offset = args.offset !== void 0 ? Number(args.offset) : void 0;
+    const params = {};
+    if (args.query !== void 0) params["query"] = args.query;
+    if (args.id !== void 0) params["id"] = args.id;
+    if (args.exact !== void 0) params["exact"] = args.exact;
+    if (args.fuzzy !== void 0) params["fuzzy"] = args.fuzzy;
+    if (args.status !== void 0) params["status"] = args.status;
+    if (args.in !== void 0) params["field"] = args.in;
+    if (args["include-archive"] !== void 0) params["includeArchive"] = args["include-archive"];
+    if (limit !== void 0) params["limit"] = limit;
+    if (offset !== void 0) params["offset"] = offset;
+    if (args.fields !== void 0) params["fields"] = args.fields;
+    if (args.verbose !== void 0) params["verbose"] = args.verbose;
+    if (args.kind !== void 0) params["kind"] = args.kind;
+    if (args.urgent !== void 0) params["urgent"] = args.urgent;
+    if (args.label !== void 0) params["label"] = args.label;
+    if (args.parent !== void 0) params["parent"] = args.parent;
+    const response = await dispatchRaw("query", "tasks", "find", params);
+    if (!response.success) {
+      handleRawError(response, { command: "find", operation: "tasks.find" });
+    }
+    const rawData = response.data;
+    const data = (Array.isArray(rawData) ? { results: rawData, total: rawData.length } : rawData) ?? {};
+    const results = Array.isArray(data?.results) ? data.results : [];
+    if (results.length === 0) {
+      const matched = typeof data?.["total"] === "number" ? data["total"] : 0;
+      const message = matched > 0 ? `No results on this page \u2014 ${matched} task(s) matched. Re-run with --all to enumerate every match, or adjust --limit/--offset.` : "No matching tasks found";
+      cliOutput(data, { command: "find", message, operation: "tasks.find" });
+      process.exit(ExitCode.NO_DATA);
+      return;
+    }
+    const total = data?.total ?? results.length;
+    const page = response.page ?? (limit === 0 && !offset ? { mode: "none" } : createPage({
+      total,
+      limit: limit === 0 ? Math.max(1, results.length) : limit ?? 20,
+      offset
+    }));
+    cliOutput(data, { command: "find", operation: "tasks.find", page, enumerateAllFlag: "--all" });
+  }
+});
+export {
+  findCommand
+};
+//# sourceMappingURL=find-5EUZHHQJ.js.map

package/dist/cli/focus-6AH4KLRO.js

@@ -0,0 +1,368 @@
+(() => {
+  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 {
+  lafsSuccess
+} from "./chunk-QWNKLLLG.js";
+import {
+  dispatchMeta,
+  handleErrorResult,
+  unsupportedOp
+} from "./chunk-XHRZ7OYZ.js";
+
+// packages/cleo/src/dispatch/domains/focus.ts
+import { execSync } from "node:child_process";
+import { runKnowledgeDoctor } from "@cleocode/core/doctor/knowledge";
+import {
+  compactKnowledgeCoverage,
+  compactKnowledgeHealth
+} from "@cleocode/core/doctor/knowledge-summary";
+import { buildAttentionDigest } from "@cleocode/core/memory/attention";
+import { memoryFind } from "@cleocode/core/memory/engine-compat";
+import { orchestrateReady } from "@cleocode/core/orchestrate/query-ops";
+import { getProjectRoot } from "@cleocode/core/project-scope";
+import { isSagaType } from "@cleocode/core/sagas/is-saga-type";
+import { createAttachmentStore } from "@cleocode/core/store/attachment-store";
+import { taskRelates } from "@cleocode/core/tasks/engine-wrap";
+import { taskShow } from "@cleocode/core/tasks/show";
+function roughTokenCount(value) {
+  try {
+    return Math.ceil(JSON.stringify(value).length / 4);
+  } catch {
+    return 0;
+  }
+}
+var TASK_ID_RE = /^T\d+$/i;
+function fetchRecentActivity(taskId, projectRoot, diagnostics) {
+  try {
+    const raw = execSync(`git log --grep="${taskId}" --pretty=format:"%H	%s	%aI" -n 5`, {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: projectRoot
+    });
+    return raw.trim().split("\n").filter(Boolean).map((line) => {
+      const parts = line.split("	");
+      return {
+        commitSha: parts[0] ?? "",
+        message: parts[1] ?? "",
+        date: parts[2] ?? ""
+      };
+    }).filter((c) => c.commitSha !== "");
+  } catch (error) {
+    diagnostics["git"] = { status: "failed", reasons: [String(error)], evidence: [] };
+    return [];
+  }
+}
+function describeEngineFailure(result) {
+  const { code, message, fix } = result.error;
+  return `${code}: ${message}${fix ? ` (fix: ${fix})` : ""}`;
+}
+async function fetchAttachedDocs(projectRoot, taskId, diagnostics) {
+  try {
+    const store = createAttachmentStore();
+    const metas = await store.listByOwner("task", taskId, projectRoot);
+    const entries = [];
+    for (const meta of metas) {
+      const extras = await store.getExtras(meta.id, projectRoot);
+      entries.push({
+        attachmentId: meta.id,
+        kind: meta.attachment.kind,
+        ...extras?.slug != null ? { slug: extras.slug } : {},
+        ...extras?.type != null ? { type: extras.type } : {}
+      });
+    }
+    return entries;
+  } catch (error) {
+    diagnostics["docs"] = { status: "failed", reasons: [String(error)], evidence: [] };
+    return [];
+  }
+}
+async function fetchBrainContext(taskId, diagnostics) {
+  try {
+    const [obsResult, decResult, lrnResult] = await Promise.allSettled([
+      memoryFind({ query: taskId, limit: 3, tables: ["observations"] }),
+      memoryFind({ query: taskId, limit: 3, tables: ["decisions"] }),
+      memoryFind({ query: taskId, limit: 3, tables: ["learnings"] })
+    ]);
+    const failures = [];
+    const fail = (table, cause) => {
+      failures.push(`${table}: ${cause}`);
+      diagnostics["memory"] = {
+        status: "failed",
+        reasons: ["One or more scoped memory retrievals failed.", ...failures],
+        evidence: []
+      };
+      return [];
+    };
+    const toHits = (table, r) => {
+      if (r.status === "rejected") return fail(table, String(r.reason));
+      if (!r.value.success) return fail(table, describeEngineFailure(r.value));
+      const data = r.value.data;
+      return (data?.results ?? []).slice(0, 3);
+    };
+    return {
+      observations: toHits("observations", obsResult),
+      learnings: toHits("learnings", lrnResult),
+      decisions: toHits("decisions", decResult)
+    };
+  } catch (error) {
+    diagnostics["memory"] = { status: "failed", reasons: [String(error)], evidence: [] };
+    return void 0;
+  }
+}
+async function fetchAttentionDigest(projectRoot, diagnostics) {
+  try {
+    const digest = await buildAttentionDigest(projectRoot);
+    return digest ?? void 0;
+  } catch (error) {
+    diagnostics["attention"] = { status: "failed", reasons: [String(error)], evidence: [] };
+    return void 0;
+  }
+}
+async function fetchSagaMembersWithTitles(projectRoot, sagaId, diagnostics) {
+  try {
+    const relResult = await taskRelates(projectRoot, sagaId);
+    if (!relResult.success) {
+      diagnostics["saga"] = {
+        status: "failed",
+        reasons: ["Saga relationship retrieval failed."],
+        evidence: []
+      };
+      return [];
+    }
+    const memberIds = (relResult.data?.relations ?? []).filter((r) => r.type === "groups").map((r) => r.taskId);
+    if (memberIds.length === 0) return [];
+    const showResults = await Promise.allSettled(
+      memberIds.map((epicId) => taskShow(projectRoot, epicId))
+    );
+    return showResults.map((r, i) => {
+      const epicId = memberIds[i] ?? "";
+      if (r.status !== "fulfilled" || !r.value.success) {
+        diagnostics["saga"] = {
+          status: "failed",
+          reasons: ["One or more saga member records could not be loaded."],
+          evidence: []
+        };
+        return { epicId, title: epicId, status: "unknown" };
+      }
+      const t = r.value.data.task;
+      return { epicId: t.id, title: t.title, status: t.status };
+    }).filter((m) => m.epicId !== "");
+  } catch (error) {
+    diagnostics["saga"] = { status: "failed", reasons: [String(error)], evidence: [] };
+    return [];
+  }
+}
+async function buildFocusEnvelope(id, projectRoot) {
+  const showResult = await taskShow(projectRoot, id);
+  if (!showResult.success) {
+    return {
+      error: {
+        code: showResult.error?.code?.toString() ?? "E_NOT_FOUND",
+        message: showResult.error?.message ?? `Task not found: ${id}`
+      }
+    };
+  }
+  const knowledge = await runKnowledgeDoctor(projectRoot, { fix: true, budgetMs: 2e3 });
+  const sourceDiagnostics = {};
+  const task = showResult.data.task;
+  const isSaga = isSagaType(task);
+  const isEpic = task.type === "epic" && !isSaga;
+  const entityType = isSaga ? "saga" : isEpic ? "epic" : "task";
+  const identity = {
+    id: task.id,
+    title: task.title,
+    type: entityType,
+    status: task.status,
+    ...task.parentId != null ? { parentId: task.parentId } : {}
+  };
+  const scope = {};
+  if (entityType === "task") {
+    scope.taskId = task.id;
+    if (task.parentId) scope.epicId = task.parentId;
+  } else if (entityType === "epic") {
+    scope.epicId = task.id;
+  } else {
+    scope.sagaId = task.id;
+  }
+  const blockers = [];
+  const explicitBlockers = Array.isArray(task.blockedBy) ? task.blockedBy : [];
+  const unresolvedDepends = [];
+  if (explicitBlockers.length === 0 && Array.isArray(task.depends)) {
+    for (const depId of task.depends) {
+      const dRes = await taskShow(projectRoot, depId).catch(() => null);
+      if (!dRes?.success)
+        sourceDiagnostics["dependencies"] = {
+          status: "failed",
+          reasons: ["A dependency record could not be assessed."],
+          evidence: []
+        };
+      if (dRes?.success && dRes.data) {
+        const s = dRes.data.task.status;
+        if (s !== "done" && s !== "cancelled") {
+          unresolvedDepends.push(depId);
+          blockers.push({
+            id: depId,
+            title: dRes.data.task.title,
+            reason: `dependency not resolved (status: ${s})`
+          });
+        }
+      }
+    }
+  }
+  if (explicitBlockers.length > 0) {
+    await Promise.allSettled(
+      explicitBlockers.map(async (bid) => {
+        const bRes = await taskShow(projectRoot, bid).catch(() => null);
+        if (!bRes?.success)
+          sourceDiagnostics["blockers"] = {
+            status: "failed",
+            reasons: ["A blocker record could not be assessed."],
+            evidence: []
+          };
+        blockers.push({
+          id: bid,
+          title: bRes?.success ? bRes.data?.task.title ?? bid : bid,
+          reason: bRes?.success ? bRes.data?.task.status ?? "unknown" : "unknown"
+        });
+      })
+    );
+  }
+  const epicIdForReady = entityType === "epic" ? task.id : entityType === "task" && task.parentId ? task.parentId : void 0;
+  const [sagaMembersResult, readyResult, docsResult, brainResult, attentionResult] = await Promise.allSettled([
+    isSaga ? fetchSagaMembersWithTitles(projectRoot, id, sourceDiagnostics) : Promise.resolve(void 0),
+    epicIdForReady && TASK_ID_RE.test(epicIdForReady) ? orchestrateReady(epicIdForReady, projectRoot) : Promise.resolve(null),
+    fetchAttachedDocs(projectRoot, id, sourceDiagnostics),
+    fetchBrainContext(id, sourceDiagnostics),
+    // T11374: Tier-2 attention digest for the calling agent's resolved scope.
+    fetchAttentionDigest(projectRoot, sourceDiagnostics)
+  ]);
+  const recentActivity = fetchRecentActivity(id, projectRoot, sourceDiagnostics);
+  const members = sagaMembersResult.status === "fulfilled" && sagaMembersResult.value != null ? sagaMembersResult.value : void 0;
+  let readyWave;
+  if (readyResult.status === "fulfilled" && readyResult.value?.success) {
+    const rData = readyResult.value.data;
+    const rTasks = rData?.readyTasks ?? [];
+    if (rTasks.length > 0) {
+      readyWave = rTasks.map((t) => ({
+        id: t.id,
+        title: t.title,
+        priority: t.priority,
+        depends: t.depends
+      }));
+    }
+  }
+  const attachedDocs = docsResult.status === "fulfilled" && docsResult.value.length > 0 ? docsResult.value : void 0;
+  const brainContext = brainResult.status === "fulfilled" ? brainResult.value : void 0;
+  const attentionDigest = attentionResult.status === "fulfilled" ? attentionResult.value : void 0;
+  for (const [name, result] of Object.entries({
+    saga: sagaMembersResult,
+    ready: readyResult,
+    docs: docsResult,
+    memory: brainResult,
+    attention: attentionResult
+  })) {
+    if (result.status === "rejected")
+      sourceDiagnostics[name] = {
+        status: "failed",
+        reasons: [String(result.reason)],
+        evidence: []
+      };
+  }
+  if (readyResult.status === "fulfilled" && readyResult.value?.success === false) {
+    sourceDiagnostics["ready"] = {
+      status: "failed",
+      reasons: ["Ready-wave assessment failed.", describeEngineFailure(readyResult.value)],
+      evidence: []
+    };
+  }
+  const envelope = {
+    identity,
+    scope,
+    coverage: compactKnowledgeCoverage(knowledge.health.coverage),
+    ...brainContext != null ? { brainContext } : {},
+    blockers,
+    ...readyWave != null ? { readyWave } : {},
+    knowledgeHealth: compactKnowledgeHealth(knowledge.health, "/coverage"),
+    sourceDiagnostics,
+    ...members != null ? { members } : {},
+    ...attachedDocs != null ? { attachedDocs } : {},
+    ...recentActivity.length > 0 ? { recentActivity } : {},
+    ...attentionDigest != null ? { attentionDigest } : {},
+    tokensEstimated: 0
+  };
+  envelope.tokensEstimated = roughTokenCount(envelope);
+  return envelope;
+}
+var QUERY_OPS = /* @__PURE__ */ new Set(["show"]);
+var FocusHandler = class {
+  /**
+   * Execute a focus query with bounded deterministic knowledge maintenance.
+   *
+   * @param operation - Operation name (`'show'`).
+   * @param params    - Raw params (must contain `id: string`).
+   */
+  async query(operation, params) {
+    const startTime = Date.now();
+    if (!QUERY_OPS.has(operation)) {
+      return unsupportedOp("query", "focus", operation, startTime);
+    }
+    try {
+      const id = typeof params?.["id"] === "string" ? params["id"].trim() : "";
+      if (!id) {
+        return {
+          meta: dispatchMeta("query", "focus", operation, startTime),
+          success: false,
+          error: { code: "E_INVALID_INPUT", message: "id is required (e.g. cleo focus T9973)" }
+        };
+      }
+      const projectRoot = getProjectRoot();
+      const result = await buildFocusEnvelope(id, projectRoot);
+      if ("error" in result) {
+        return {
+          meta: dispatchMeta("query", "focus", operation, startTime),
+          success: false,
+          error: result.error
+        };
+      }
+      const wrapped = lafsSuccess(result, "focus.show");
+      return {
+        meta: dispatchMeta("query", "focus", operation, startTime),
+        success: true,
+        data: wrapped.data
+      };
+    } catch (error) {
+      return handleErrorResult("query", "focus", operation, error, startTime);
+    }
+  }
+  /**
+   * The focus domain has no mutate operations.
+   *
+   * @param operation - Always unsupported.
+   * @param _params   - Unused.
+   */
+  async mutate(operation, _params) {
+    const startTime = Date.now();
+    return unsupportedOp("mutate", "focus", operation, startTime);
+  }
+  /** Declared operations for introspection. */
+  getSupportedOperations() {
+    return { query: ["show"], mutate: [] };
+  }
+};
+export {
+  FocusHandler
+};
+//# sourceMappingURL=focus-6AH4KLRO.js.map