@iowarp/clio-coder 0.4.3 → 0.4.5

package/dist/wiki-generate-7BV7XWIY.js

@@ -0,0 +1,614 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  SchedulingDomainModule,
+  createPromptsDomainModule
+} from "./chunk-DIMRLNIC.js";
+import {
+  ConfigDomainModule,
+  loadDomains
+} from "./chunk-ILJ7DWGE.js";
+import "./chunk-YYB3MC65.js";
+import {
+  createObservabilityDomainModule
+} from "./chunk-FSTIBAGM.js";
+import "./chunk-HR3HPQ76.js";
+import "./chunk-O2RQ7LCK.js";
+import {
+  ResourcesDomainModule
+} from "./chunk-U7VQ4NI4.js";
+import {
+  AgentsDomainModule
+} from "./chunk-NY6IWDVU.js";
+import "./chunk-EQEJJ53P.js";
+import "./chunk-3UW3KU4A.js";
+import "./chunk-QRFXEO6Y.js";
+import "./chunk-LZBMXNLP.js";
+import "./chunk-T7FDXNRU.js";
+import "./chunk-DNCE23JJ.js";
+import "./chunk-U7H5WRG5.js";
+import {
+  runWithBudget,
+  writeShutdownNotice
+} from "./chunk-BS4GAMUB.js";
+import {
+  ContextDomainModule,
+  DispatchDomainModule,
+  buildWikiPagePrompt,
+  buildWikiPlanPrompt,
+  inspectWikiPageEvidence
+} from "./chunk-SDWNDICN.js";
+import "./chunk-PECBKCDK.js";
+import "./chunk-ODUTYZIU.js";
+import "./chunk-P5SC4DLJ.js";
+import "./chunk-GNQRWTMY.js";
+import "./chunk-ONRTXOZY.js";
+import {
+  SafetyDomainModule
+} from "./chunk-WLMSOT73.js";
+import "./chunk-6CDNRHWH.js";
+import {
+  SessionDomainModule
+} from "./chunk-F34AR6O3.js";
+import "./chunk-U44YYLVV.js";
+import "./chunk-UQIVHSE4.js";
+import "./chunk-USZA7GWL.js";
+import {
+  MAX_PAGE_ATTEMPTS,
+  pendingPages,
+  readAuthoredWikiPlan,
+  writeWikiPlanFile
+} from "./chunk-LVFANMOH.js";
+import "./chunk-WTQGRBHV.js";
+import "./chunk-7WUZEB2M.js";
+import "./chunk-O5F25NIE.js";
+import "./chunk-5DDOTTG4.js";
+import "./chunk-YEJIG7LN.js";
+import "./chunk-CXQ37WJH.js";
+import "./chunk-HGSLRG33.js";
+import "./chunk-7YJWEF2L.js";
+import "./chunk-SD7SHNDW.js";
+import "./chunk-T52TPHYC.js";
+import "./chunk-QH3ZTUOA.js";
+import "./chunk-LQTKDAUO.js";
+import "./chunk-22PQ4TX4.js";
+import "./chunk-DZK63TZJ.js";
+import "./chunk-DNHVRBH4.js";
+import {
+  MiddlewareDomainModule
+} from "./chunk-DRD2A54W.js";
+import "./chunk-TZ7MFRG4.js";
+import "./chunk-KF6GFW6O.js";
+import "./chunk-K2HL3GBL.js";
+import "./chunk-7HBHHVCK.js";
+import "./chunk-2GPGAE5W.js";
+import "./chunk-SL2RDHKO.js";
+import "./chunk-YGDMBK7O.js";
+import "./chunk-V552WL53.js";
+import "./chunk-RLTT5GVY.js";
+import "./chunk-KECNXMDE.js";
+import "./chunk-4SVIVOMC.js";
+import "./chunk-NTK3WTHM.js";
+import "./chunk-WXA2CFJO.js";
+import "./chunk-CBSKDFWL.js";
+import "./chunk-LY4N4TTL.js";
+import "./chunk-OQM5IVJY.js";
+import "./chunk-LUL5Z66S.js";
+import "./chunk-M6TAYK66.js";
+import "./chunk-KQ6IDQIB.js";
+import {
+  declaredScopeIntent
+} from "./chunk-L4N3DWNW.js";
+import "./chunk-WJIMKGD6.js";
+import "./chunk-MDU3C27C.js";
+import {
+  asDirectoryPathBoundary
+} from "./chunk-R2P2U3ZS.js";
+import "./chunk-NTTS3O53.js";
+import "./chunk-M4KFUXS7.js";
+import "./chunk-GH5ZR6JP.js";
+import "./chunk-VQD7NH7Z.js";
+import "./chunk-O3VV6IVK.js";
+import "./chunk-5ZMXGW7P.js";
+import "./chunk-B6UM3OZC.js";
+import "./chunk-MYI32N4R.js";
+import {
+  ToolNames
+} from "./chunk-EHOSNVVM.js";
+import {
+  ProvidersDomainModule,
+  canonicalizeWireModelId
+} from "./chunk-TEG3RYVZ.js";
+import "./chunk-MCJKEGHO.js";
+import "./chunk-77CZRFTE.js";
+import "./chunk-J2FYEQ5L.js";
+import "./chunk-FKIOX6DS.js";
+import "./chunk-DVNAPPXU.js";
+import "./chunk-5CY4Q6QI.js";
+import "./chunk-FQOOGXBH.js";
+import "./chunk-UHW5V7HC.js";
+import "./chunk-KMF54VH3.js";
+import "./chunk-5A6XR3RJ.js";
+import "./chunk-EFSEIZE6.js";
+import "./chunk-B5ZTR6KZ.js";
+import "./chunk-HL26ADLH.js";
+import "./chunk-VHKTOLEW.js";
+import "./chunk-KPRLAMP4.js";
+import "./chunk-W2RJEH6Q.js";
+import "./chunk-CVDAFGPW.js";
+import "./chunk-PPEZJWUG.js";
+import "./chunk-WDV62RKY.js";
+import "./chunk-GD55RTIW.js";
+import "./chunk-E3LEPLQ2.js";
+import "./chunk-ICO4TQ2F.js";
+import "./chunk-SE4ZKILO.js";
+import "./chunk-U2MSJ57E.js";
+import "./chunk-C27U2TYG.js";
+import "./chunk-GJ24ODAX.js";
+import "./chunk-LTR5QCLS.js";
+import "./chunk-6EXUUOSN.js";
+import "./chunk-ZTNFYMIO.js";
+import "./chunk-HHVJNVUJ.js";
+import "./chunk-HXHFDHB6.js";
+import "./chunk-VNBICSS2.js";
+import "./chunk-2QPI3TR3.js";
+import "./chunk-TK2BMCBZ.js";
+import "./chunk-B5GGDIHT.js";
+import "./chunk-ZZFWWYLX.js";
+import "./chunk-SRCEQKQS.js";
+import "./chunk-TN5FW4XY.js";
+import "./chunk-5CMARGPF.js";
+import "./chunk-DXVMLM3Z.js";
+import "./chunk-CKK25WN3.js";
+import "./chunk-CTTI7G3T.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/cli/wiki-generate.ts
+init_esm_shims();
+import { existsSync } from "node:fs";
+import { join, relative } from "node:path";
+import { performance } from "node:perf_hooks";
+var UNRESOLVED_DOCUMENTER_MODEL = "unresolved-documenter-target";
+var WIKI_AGENT_ID = "wiki-writer";
+var PAGE_ESTIMATE_MS = 6 * 60 * 1e3;
+var PLAN_ESTIMATE_MS = 8 * 60 * 1e3;
+var RUN_ESTIMATE_MS = 60 * 60 * 1e3;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function routeFields(route) {
+  return {
+    ...route.target !== void 0 ? { target: route.target } : {},
+    ...route.model !== void 0 ? { model: route.model } : {},
+    ...route.thinkingLevel !== void 0 ? { thinkingLevel: route.thinkingLevel } : {}
+  };
+}
+function eventPayloadString(event, key) {
+  if (!isRecord(event) || !isRecord(event.payload)) return null;
+  const value = event.payload[key];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function formatElapsed(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return "elapsed unknown";
+  if (ms < 1e3) return `elapsed ${Math.round(ms)}ms`;
+  return `elapsed ${Math.round(ms / 1e3)}s`;
+}
+var BLOCK_REASON_MAX_CHARS = 80;
+function summarizeBlockReason(reason) {
+  const firstSentence = reason.split(/(?<=[.;])\s/, 1)[0]?.trim() ?? reason.trim();
+  const collapsed = firstSentence.replace(/\s+/g, " ");
+  return collapsed.length <= BLOCK_REASON_MAX_CHARS ? collapsed : `${collapsed.slice(0, BLOCK_REASON_MAX_CHARS - 1).trimEnd()}\u2026`;
+}
+var HEARTBEAT_MS = 3e4;
+async function drainDispatchEvents(events, onActivity) {
+  const tools = /* @__PURE__ */ new Map();
+  let completed = 0;
+  let errors = 0;
+  let blocked = 0;
+  let firstBlockReason = null;
+  for await (const event of events) {
+    if (!isRecord(event) || event.type !== "clio_coder_tool_finish") continue;
+    const tool = eventPayloadString(event, "tool");
+    if (!tool) continue;
+    const outcome = eventPayloadString(event, "outcome") ?? "done";
+    completed += 1;
+    tools.set(tool, (tools.get(tool) ?? 0) + 1);
+    if (outcome === "error") errors += 1;
+    if (outcome === "blocked") {
+      blocked += 1;
+      firstBlockReason ??= eventPayloadString(event, "reason");
+    }
+    onActivity?.(completed);
+  }
+  const mix = [...tools.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([tool, count]) => `${tool}=${count}`).join(", ");
+  return { tools: completed, errors, blocked, firstBlockReason, mix };
+}
+function summaryDetail(summary, startedAtClock) {
+  const blockedDetail = summary.blocked > 0 ? `; blocked=${summary.blocked}${summary.firstBlockReason ? ` (${summarizeBlockReason(summary.firstBlockReason)})` : ""}` : "";
+  return `${formatElapsed(performance.now() - startedAtClock)}; ${summary.mix || "no tools completed"}${summary.errors > 0 ? `; errors=${summary.errors}` : ""}${blockedDetail}`;
+}
+function explicitWikiDeadline(options) {
+  if (options.runBudgetMs !== void 0 && (!Number.isFinite(options.runBudgetMs) || options.runBudgetMs < 0))
+    throw new Error("wiki runBudgetMs must be a finite non-negative duration");
+  if (options.deadlineAt !== void 0 && !Number.isFinite(options.deadlineAt))
+    throw new Error("wiki deadlineAt must be a finite timestamp");
+  if (options.deadlineAt === void 0 && options.runBudgetMs === void 0) return void 0;
+  const wallNow = Date.now();
+  const at = Math.min(
+    options.deadlineAt ?? Number.POSITIVE_INFINITY,
+    wallNow + (options.runBudgetMs ?? Number.POSITIVE_INFINITY)
+  );
+  if (!Number.isFinite(new Date(at).getTime())) throw new Error("wiki deadline exceeds the supported timestamp range");
+  const clockNow = performance.now();
+  return { at, remainingMs: () => at - wallNow - (performance.now() - clockNow) };
+}
+async function runWikiDispatch(input) {
+  const startedAtClock = performance.now();
+  let handle;
+  try {
+    if (input.deadline && input.deadline.remainingMs() <= 0)
+      throw new Error("explicit wiki deadline reached before admission");
+    const stagingRoot = relative(input.cwd, input.outputDir);
+    if (!stagingRoot) throw new Error("wiki staging directory must be below the repository root");
+    const scope = declaredScopeIntent({ readRoots: ["."], writeRoots: [asDirectoryPathBoundary(stagingRoot)] });
+    if (!scope.ok) throw new Error(`${scope.reason}: ${scope.message}`);
+    handle = await input.dispatch.dispatch({
+      intent: scope.intent,
+      agentId: WIKI_AGENT_ID,
+      executionRole: "builder",
+      task: input.task,
+      ...input.artifactPath !== void 0 ? { resultContractOverride: { kind: "artifact-report", path: input.artifactPath } } : {},
+      cwd: input.cwd,
+      requestOrigin: "internal",
+      noSkills: true,
+      ...routeFields(input.route),
+      // `git` cannot answer anything for this dispatch. The prompt already
+      // embeds `git status` and `git log` verbatim, and the staging dir is
+      // under the gitignored `.clio-coder/`, so `op=diff` cannot see the pages this
+      // run is writing.
+      denyTools: [ToolNames.Git],
+      // Containment: the worker safety seam blocks any write-class tool call
+      // whose target escapes the staging dir.
+      writeRoots: [asDirectoryPathBoundary(input.outputDir)],
+      // Only an explicit caller deadline constrains admission; recipe estimates
+      // must not become assignment deadlines or restart for each page.
+      ...input.deadline ? { assignmentDeadlineAt: input.deadline.at } : {}
+    });
+  } catch (err) {
+    return { ok: false, phase: "admission", detail: err instanceof Error ? err.message : String(err) };
+  }
+  let timedOut = false;
+  let timer;
+  const armDeadline = () => {
+    if (!input.deadline) return;
+    const remaining = input.deadline.remainingMs();
+    if (remaining <= 0) {
+      timedOut = true;
+      input.dispatch.abort(handle.runId, { cause: "timeout", detail: "explicit wiki deadline reached" });
+      return;
+    }
+    timer = setTimeout(armDeadline, Math.min(remaining, 2147483647));
+    timer.unref();
+  };
+  armDeadline();
+  let lastHeartbeatAt = startedAtClock;
+  try {
+    const summary = await drainDispatchEvents(handle.events, (tools) => {
+      const nowMs = performance.now();
+      if (!input.onHeartbeat || nowMs - lastHeartbeatAt < HEARTBEAT_MS) return;
+      lastHeartbeatAt = nowMs;
+      input.onHeartbeat({ elapsedMs: Math.round(nowMs - startedAtClock), tools });
+    });
+    const receipt = await handle.finalPromise;
+    if (timedOut)
+      return {
+        ok: false,
+        phase: "writer",
+        runId: handle.runId,
+        detail: `timed out; ${summaryDetail(summary, startedAtClock)}`
+      };
+    if (receipt.exitCode !== 0) {
+      input.dispatch.abort(handle.runId);
+      return {
+        ok: false,
+        phase: "writer",
+        runId: handle.runId,
+        detail: `${receiptFailure(receipt)}; ${summaryDetail(summary, startedAtClock)}`
+      };
+    }
+    return { ok: true, phase: "writer", runId: handle.runId, detail: summaryDetail(summary, startedAtClock) };
+  } catch (err) {
+    if (!timedOut) input.dispatch.abort(handle.runId);
+    await handle.finalPromise.catch(() => void 0);
+    const reason = timedOut ? "timed out" : err instanceof Error ? err.message : String(err);
+    return {
+      ok: false,
+      phase: "writer",
+      runId: handle.runId,
+      detail: `${reason}; ${formatElapsed(performance.now() - startedAtClock)}`
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function receiptFailure(receipt) {
+  const code = receipt.outcomeCode ? ` (${receipt.outcomeCode})` : "";
+  const detail = receipt.outcomeDetail?.replace(/\s+/gu, " ").slice(0, 350);
+  return `exit ${receipt.exitCode}${code}${detail ? `: ${detail}` : ""}`;
+}
+async function runPlanPhase(dispatch, input, route, deadline) {
+  input.progress?.({ phase: "generate", status: "running", message: "planning wiki pages" });
+  const outcome = await runWikiDispatch({
+    dispatch,
+    cwd: input.cwd,
+    outputDir: input.outputDir,
+    task: buildWikiPlanPrompt({
+      cwd: input.cwd,
+      mode: input.mode,
+      codewiki: input.codewiki,
+      generation: input.generation,
+      plan: input.plan,
+      unclaimedAreas: input.unclaimedAreas,
+      outputDir: input.outputDir,
+      gitHead: input.gitHead ?? null
+    }),
+    route,
+    deadline,
+    onHeartbeat: ({ elapsedMs, tools }) => input.progress?.({
+      phase: "generate",
+      status: "running",
+      message: `still planning (${formatElapsed(elapsedMs)}, ${tools} tool calls)`,
+      detail: `planner estimate ${Math.round(PLAN_ESTIMATE_MS / 6e4)}m; healthy work may continue longer`
+    })
+  });
+  const revised = readAuthoredWikiPlan(input.outputDir, input.plan);
+  const plan = revised ?? input.plan;
+  input.progress?.({
+    phase: "generate",
+    status: "running",
+    message: outcome.ok ? `plan has ${plan.pages.length} page${plan.pages.length === 1 ? "" : "s"}` : "planner did not finish; using the indexed candidate plan",
+    detail: outcome.detail
+  });
+  return plan;
+}
+async function runPagePhase(dispatch, input, plan, page, route, position, deadline) {
+  const seeded = existsSync(join(input.outputDir, page.path));
+  const outcome = await runWikiDispatch({
+    dispatch,
+    cwd: input.cwd,
+    outputDir: input.outputDir,
+    artifactPath: relative(input.cwd, join(input.outputDir, page.path)),
+    task: buildWikiPagePrompt({
+      depth: input.generation.depth,
+      cwd: input.cwd,
+      mode: input.mode,
+      codewiki: input.codewiki,
+      page,
+      siblings: plan.pages,
+      ...input.decisions ? { decisions: input.decisions } : {},
+      outputDir: input.outputDir,
+      seeded
+    }),
+    route,
+    deadline,
+    onHeartbeat: ({ elapsedMs, tools }) => input.progress?.({
+      phase: "generate",
+      status: "running",
+      message: `still writing ${page.path} (${position.index}/${position.total}, ${formatElapsed(elapsedMs)}, ${tools} tool calls)`,
+      detail: `page estimate ${Math.round(PAGE_ESTIMATE_MS / 6e4)}m; healthy work may continue longer`
+    })
+  });
+  const evidence = outcome.ok ? inspectWikiPageEvidence({
+    pagePath: page.path,
+    outputDir: input.outputDir,
+    sourceRoot: input.cwd
+  }) : void 0;
+  const written = outcome.ok && evidence?.ok === true;
+  const detail = evidence && !evidence.ok ? `evidence check failed: ${evidence.reasons.join("; ")}` : outcome.detail;
+  const next = {
+    ...plan,
+    pages: plan.pages.map((entry) => {
+      if (entry.path !== page.path) return entry;
+      const nextPage = {
+        ...entry,
+        status: written ? "written" : "pending",
+        ...written ? { dependencies: evidence?.dependencies ?? [] } : {},
+        attempts: entry.attempts + (outcome.phase === "writer" ? 1 : 0)
+      };
+      if (written) delete nextPage.lastFailure;
+      else
+        nextPage.lastFailure = {
+          phase: outcome.ok ? "validation" : outcome.phase,
+          detail: detail.replace(/\s+/gu, " ").slice(0, 500),
+          ...outcome.phase === "writer" ? { runId: outcome.runId } : {}
+        };
+      return nextPage;
+    })
+  };
+  writeWikiPlanFile(input.outputDir, next);
+  input.progress?.({
+    phase: "generate",
+    status: "running",
+    message: `${written ? "wrote" : "could not write"} ${page.path} (${position.index}/${position.total})`,
+    detail
+  });
+  return next;
+}
+async function generateWikiWithDocumenter(dispatch, input, route = {}, deadline, signal) {
+  signal?.throwIfAborted();
+  const startedAtClock = performance.now();
+  const routeDetail = [route.target, route.model, route.thinkingLevel ? `thinking=${route.thinkingLevel}` : void 0].filter((value) => value !== void 0).join("/");
+  input.progress?.({
+    phase: "generate",
+    status: "running",
+    message: "dispatching wiki writers",
+    detail: `one page per dispatch${routeDetail ? `; ${routeDetail}` : ""}`
+  });
+  let plan = input.resumed ? input.plan : await runPlanPhase(dispatch, input, route, deadline);
+  signal?.throwIfAborted();
+  if (!input.resumed) writeWikiPlanFile(input.outputDir, plan);
+  const queue = pendingPages(plan, input.retryPending);
+  if (queue.length === 0) {
+    const pending = plan.pages.filter((page) => page.status !== "written").length;
+    input.progress?.({
+      phase: "generate",
+      status: "running",
+      message: pending > 0 ? `${pending} pending page${pending === 1 ? " has" : "s have"} exhausted writer attempts` : "every planned page is already current"
+    });
+    return;
+  }
+  {
+    const estimateMs = Math.min(RUN_ESTIMATE_MS, queue.length * PAGE_ESTIMATE_MS);
+    input.progress?.({
+      phase: "generate",
+      status: "running",
+      message: `${queue.length} page${queue.length === 1 ? "" : "s"} to write, one model run each`,
+      detail: `estimate ${Math.round(estimateMs / 6e4)}m; activity summaries every ${Math.round(HEARTBEAT_MS / 1e3)}s; finished pages are kept if the run stops early${deadline ? `; explicit deadline ${new Date(deadline.at).toISOString()}` : "; healthy work may continue beyond estimates"}`
+    });
+  }
+  for (const [index, page] of queue.entries()) {
+    signal?.throwIfAborted();
+    if (deadline && deadline.remainingMs() <= 0) {
+      const left = queue.length - index;
+      input.progress?.({
+        phase: "generate",
+        status: "running",
+        message: `explicit deadline reached with ${left} page${left === 1 ? "" : "s"} unwritten`,
+        detail: `${formatElapsed(performance.now() - startedAtClock)}; staged pages are kept and promoted`
+      });
+      return;
+    }
+    const current = plan.pages.find((entry) => entry.path === page.path) ?? page;
+    if (current.status === "written" || !input.retryPending && current.attempts >= MAX_PAGE_ATTEMPTS) continue;
+    plan = await runPagePhase(
+      dispatch,
+      input,
+      plan,
+      current,
+      route,
+      {
+        index: index + 1,
+        total: queue.length
+      },
+      deadline
+    );
+  }
+}
+async function loadWikiDispatch() {
+  const loaded = await loadDomains([
+    ConfigDomainModule,
+    ResourcesDomainModule,
+    ContextDomainModule,
+    ProvidersDomainModule,
+    SafetyDomainModule,
+    createPromptsDomainModule({ noContextFiles: true }),
+    AgentsDomainModule,
+    MiddlewareDomainModule,
+    SessionDomainModule,
+    createObservabilityDomainModule({ dispatchTrace: false }),
+    SchedulingDomainModule,
+    DispatchDomainModule
+  ]);
+  const dispatch = loaded.getContract("dispatch");
+  if (!dispatch) {
+    await loaded.stop();
+    throw new Error("wiki writer dispatch unavailable");
+  }
+  return { dispatch, loaded };
+}
+async function resolveDocumenterModelId(route = {}) {
+  const loaded = await loadDomains([ConfigDomainModule, ResourcesDomainModule, ProvidersDomainModule]);
+  try {
+    const config = loaded.getContract("config");
+    const providers = loaded.getContract("providers");
+    if (!config || !providers) return UNRESOLVED_DOCUMENTER_MODEL;
+    const settings = config.get();
+    const workers = settings.fleet;
+    const bindingProfileName = workers?.agentProfiles?.[WIKI_AGENT_ID];
+    const profile = bindingProfileName ? workers?.profiles?.[bindingProfileName] : void 0;
+    const targetId = route.target ?? profile?.target ?? workers?.default?.target ?? settings.targets?.[0]?.id ?? null;
+    if (!targetId) return UNRESOLVED_DOCUMENTER_MODEL;
+    const target = providers.getTarget(targetId);
+    const requestedModel = route.model ?? profile?.model ?? workers?.default?.model ?? target?.defaultModel ?? null;
+    if (!requestedModel) return UNRESOLVED_DOCUMENTER_MODEL;
+    const status = providers.list().find((entry) => entry.target.id === targetId);
+    return status ? canonicalizeWireModelId(status, requestedModel) : requestedModel;
+  } catch {
+    return UNRESOLVED_DOCUMENTER_MODEL;
+  } finally {
+    await loaded.stop();
+  }
+}
+async function withWikiDispatchLifecycle(runtime, generate) {
+  const abort = new AbortController();
+  let closing = null;
+  let interrupted = null;
+  const close = () => {
+    closing ??= (async () => {
+      let failure2 = null;
+      try {
+        await runtime.dispatch.drain();
+      } catch (error) {
+        failure2 = { error };
+      }
+      try {
+        await runtime.stop();
+      } catch (error) {
+        if (failure2) writeShutdownNotice(`clio-coder context wiki: domain cleanup failed: ${String(error)}`);
+        else failure2 = { error };
+      }
+      if (failure2) throw failure2.error;
+    })();
+    return closing;
+  };
+  const exitCodes = { SIGINT: 130, SIGTERM: 143, SIGHUP: 129 };
+  const onSignal = (signal) => {
+    if (interrupted) return;
+    abort.abort(new Error(`wiki generation interrupted by ${signal}`));
+    interrupted = (async () => {
+      const completed = await runWithBudget(close, 2e3, (error) => {
+        writeShutdownNotice(`clio-coder context wiki: shutdown failed: ${String(error)}`);
+      });
+      if (!completed) writeShutdownNotice("clio-coder context wiki: shutdown exceeded 2000ms budget");
+      process.exit(exitCodes[signal]);
+    })();
+  };
+  for (const signal of Object.keys(exitCodes)) process.on(signal, onSignal);
+  let failure = null;
+  try {
+    await generate(abort.signal);
+  } catch (error) {
+    failure = { error };
+  }
+  try {
+    if (interrupted) await interrupted;
+    else await close();
+  } catch (error) {
+    if (failure) writeShutdownNotice(`clio-coder context wiki: cleanup failed: ${String(error)}`);
+    else failure = { error };
+  } finally {
+    for (const signal of Object.keys(exitCodes)) process.off(signal, onSignal);
+  }
+  if (failure) throw failure.error;
+}
+function modelWikiGenerate(options = {}) {
+  return async (input) => {
+    const deadline = explicitWikiDeadline(options);
+    if (options.dispatch) {
+      await generateWikiWithDocumenter(options.dispatch, input, options.route, deadline);
+      return;
+    }
+    const { dispatch, loaded } = await loadWikiDispatch();
+    await withWikiDispatchLifecycle(
+      { dispatch, stop: () => loaded.stop() },
+      (signal) => generateWikiWithDocumenter(dispatch, input, options.route, deadline, signal)
+    );
+  };
+}
+export {
+  modelWikiGenerate,
+  resolveDocumenterModelId,
+  withWikiDispatchLifecycle
+};
+//# sourceMappingURL=wiki-generate-7BV7XWIY.js.map