@iowarp/clio-coder 0.3.0

package/dist/chunk-O4EJEDHO.js

@@ -0,0 +1,659 @@
+import {
+  armInternalDispatchDeadline
+} from "./chunk-4UQA7NCT.js";
+import {
+  SchedulingDomainModule,
+  createPromptsDomainModule
+} from "./chunk-3DANZDGR.js";
+import {
+  AgentsDomainModule,
+  SafetyDomainModule
+} from "./chunk-JPOWPFCU.js";
+import {
+  ConfigDomainModule,
+  loadDomains
+} from "./chunk-527KG6XR.js";
+import {
+  fallbackBootstrapOutput
+} from "./chunk-UWIJNAOB.js";
+import {
+  renderCodewikiDigest
+} from "./chunk-X3BR7HWV.js";
+import {
+  DispatchDomainModule,
+  MiddlewareDomainModule,
+  SessionDomainModule,
+  UnsupportedResponseSchemaError,
+  createObservabilityDomainModule,
+  isResponseSchemaRejection
+} from "./chunk-GNGDQYDU.js";
+import {
+  ResourcesDomainModule
+} from "./chunk-2J63S4SF.js";
+import {
+  ProvidersDomainModule
+} from "./chunk-TKHQ4DGZ.js";
+
+// src/domains/context/bootstrap-prompt.ts
+var BOOTSTRAP_PROMPT = `You are the clio-coder bootstrap agent. Your job is to write the custom sections of CLIO-CODER.md for the project at <cwd>. CLIO-CODER.md is a lean, project-specific handbook that the clio-coder coding agent loads on every session, so write for an experienced engineer who has never seen this repository and is about to change it.
+
+Read the repository before you answer: start with code_nav (modes symbol, path, entries, outline, deps, dependents, wiki) against the index Clio just built, then read the specific files that decide behavior. Do not write files, run tests, or use external sources.
+
+You will be given:
+- The repository-derived project name. Return it exactly as projectName; do not substitute a path or invent a brand.
+- The detected project type.
+- The existing CLIO-CODER.md when one is present. Treat it as evidence; Clio preserves its human-owned fields outside your response.
+- A structural digest from the codewiki index: module count, entry points, and top directories.
+- A sanitized adoption scan of project-local agent configs, including Claude Code context files and skills (CLAUDE.md, .claude/CLAUDE.md, project settings/commands/agents/skills), Codex (AGENTS.md, CODEX.md, .codex/AGENTS.md, .codex/skills), Gemini (GEMINI.md, .gemini/GEMINI.md, .gemini config/rules), Cursor (.cursor/rules/*.mdc and *.md), OpenCode (.opencode/skills), and GitHub Copilot (.github/copilot-instructions.md, .github/skills).
+- Global user preferences only when the user explicitly opted in.
+
+THE CITATION RULE, which Clio enforces after you answer: a line survives only when it contains at least one backticked token, and every backticked token names something real in this repository, meaning an indexed file path, a symbol, a runnable package script, or a string that occurs in the supplied evidence. A line that cites nothing is deleted. A line that cites something that does not exist is deleted. Write every line so that it names the file, symbol, or command it is about.
+
+Clio's deterministic layer owns the project name, identity, conventions, hard invariants, the navigation and repository-shape sections, agent-context provenance, and the verification-command section. Set projectName to the supplied expectedProjectName, keep identity to one short sentence, and return empty conventions and invariants arrays.
+
+Your contribution is two to four custom H2 sections, chosen from these, in this order of value:
+- "Architecture": the control flow a change has to travel through, named file by file. Say which module owns which decision, and which files are coupled and must change together. This is the section that requires reading, so it is the one worth the most.
+- "Gotchas": invariants that are easy to break. Each item names the file that enforces it and the consequence of breaking it, especially where a violation degrades silently instead of failing loudly.
+- "Extending": for the two or three most likely kinds of change, the exact set of files that must be touched together.
+- "Commands": only development commands that Clio's verification section will not already state, such as running a single test, a dry-run mode, or a debug environment variable.
+
+Prefer specific over complete. Six lines that name real files beat twenty lines of summary. State a size warning when a file is large enough that reading it top to bottom is the wrong move. A fenced block is acceptable for commands; Clio inlines it.
+
+Copy commands, file paths, symbols, and version constraints exactly. Never repair, combine, or paraphrase a shell command. Never invent an API endpoint, an example, an ownership team, a review requirement, a release process, or a file count. If you did not read it or it was not supplied, do not write it.
+
+Do not include a project map, a file tree, a dependency inventory, a language-idiom list, preferences, communication-style content, secrets, credentials, auth tokens, caches, histories, generated state, fingerprint metadata, or imported-context provenance. Clio adds its deterministic surfaces after parsing. Keep the complete custom-section payload under 2500 bytes.
+
+Return one assistant message containing only compact JSON with this exact shape. Do not include markdown fences, prose, explanation, or commentary:
+{
+  "projectName": "string",
+  "identity": "string",
+  "conventions": ["string"],
+  "invariants": ["string"],
+  "sections": [{ "title": "string", "body": "markdown string" }]
+}`;
+var BOOTSTRAP_OUTPUT_JSON_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["projectName", "identity", "conventions", "invariants", "sections"],
+  properties: {
+    // Keep the provider schema to llama.cpp's portable grammar subset.
+    // parseBootstrapModelOutput enforces all string and array bounds below.
+    projectName: { type: "string" },
+    identity: { type: "string" },
+    conventions: {
+      type: "array",
+      items: { type: "string" }
+    },
+    invariants: {
+      type: "array",
+      items: { type: "string" }
+    },
+    sections: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["title", "body"],
+        properties: {
+          title: { type: "string" },
+          body: { type: "string" }
+        }
+      }
+    }
+  }
+};
+function truncate(value, max) {
+  if (value.length <= max) return value;
+  const marker = "\n[truncated]";
+  if (max <= marker.length) return value.slice(0, max);
+  return `${value.slice(0, max - marker.length)}${marker}`;
+}
+var BOOTSTRAP_INPUT_MAX_CHARS = 48e3;
+var BOOTSTRAP_SIBLING_MAX_FILES = 12;
+var BOOTSTRAP_SIBLING_CONTENT_MAX_CHARS = 12e3;
+function sourceSummaries(files, adoption) {
+  const selected = files.slice(0, BOOTSTRAP_SIBLING_MAX_FILES);
+  const perFileLimit = Math.min(
+    3e3,
+    Math.max(1, Math.floor(BOOTSTRAP_SIBLING_CONTENT_MAX_CHARS / Math.max(1, selected.length)))
+  );
+  const displayPath = new Map(adoption.sources.map((source) => [source.path, source.displayPath]));
+  return selected.map((file) => ({
+    scope: file.source,
+    path: truncate(displayPath.get(file.path) ?? file.path, 240),
+    content: truncate(file.content, perFileLimit)
+  }));
+}
+function compactImportedRules(adoption) {
+  return adoption.importedRules.slice(0, 12).map((rule) => ({
+    text: truncate(rule.text, 240),
+    sources: rule.sources.slice(0, 2).map((source) => truncate(source, 160)),
+    providers: rule.providers.slice(0, 2).map((provider) => truncate(provider, 80)),
+    ...rule.directoryScopes ? { directoryScopes: rule.directoryScopes.slice(0, 2).map((scope) => truncate(scope, 160)) } : {},
+    ...rule.conflictKey ? { conflictKey: truncate(rule.conflictKey, 80) } : {}
+  }));
+}
+function compactConflicts(adoption) {
+  return adoption.conflicts.slice(0, 6).map((conflict) => ({
+    key: truncate(conflict.key, 80),
+    kept: truncate(conflict.kept, 240),
+    keptSources: conflict.keptSources.slice(0, 2).map((source) => truncate(source, 160)),
+    skipped: conflict.skipped.slice(0, 1).map((skipped) => ({
+      text: truncate(skipped.text, 240),
+      source: truncate(skipped.source, 160),
+      provider: truncate(skipped.provider, 80)
+    }))
+  }));
+}
+function compactRejected(adoption) {
+  return adoption.rejected.slice(0, 8).map((rejected) => ({
+    path: truncate(rejected.displayPath, 240),
+    scope: rejected.scope,
+    ...rejected.provider ? { provider: rejected.provider } : {},
+    reason: truncate(rejected.reason, 160)
+  }));
+}
+function buildBootstrapPrompt(input) {
+  const siblingFiles = sourceSummaries(input.siblingFiles, input.adoption);
+  const importedRules = compactImportedRules(input.adoption);
+  const conflicts = compactConflicts(input.adoption);
+  const rejected = compactRejected(input.adoption);
+  const adoption = {
+    includeGlobal: input.adoption.includeGlobal,
+    sourceCount: input.adoption.sources.length,
+    presentedSourceCount: siblingFiles.length,
+    importedRuleCount: input.adoption.importedRules.length,
+    conflictCount: input.adoption.conflicts.length,
+    rejectedCount: input.adoption.rejected.length,
+    importedRules,
+    conflicts,
+    rejected
+  };
+  const payload = {
+    projectRoot: ".",
+    expectedProjectName: truncate(input.expectedProjectName ?? "Project", 80),
+    projectType: input.projectType,
+    ...input.existingClioMdText ? { existingClioMd: truncate(input.existingClioMdText, 8e3) } : {},
+    ...input.codewiki ? { codewikiDigest: renderCodewikiDigest(input.codewiki, 1200) } : {},
+    siblingFiles,
+    adoption
+  };
+  let serialized = JSON.stringify(payload);
+  while (serialized.length > BOOTSTRAP_INPUT_MAX_CHARS) {
+    if (rejected.length > 0) rejected.pop();
+    else if (conflicts.length > 0) conflicts.pop();
+    else if (siblingFiles.length > 1) siblingFiles.pop();
+    else if (importedRules.length > 1) importedRules.pop();
+    else break;
+    adoption.presentedSourceCount = siblingFiles.length;
+    serialized = JSON.stringify(payload);
+  }
+  if (serialized.length > BOOTSTRAP_INPUT_MAX_CHARS) {
+    serialized = JSON.stringify({
+      projectRoot: ".",
+      expectedProjectName: truncate(input.expectedProjectName ?? "Project", 80),
+      projectType: input.projectType,
+      ...input.existingClioMdText ? { existingClioMd: truncate(input.existingClioMdText, 2e3) } : {},
+      ...input.codewiki ? { codewikiDigest: renderCodewikiDigest(input.codewiki, 1200) } : {},
+      siblingFiles: [],
+      adoption: {
+        includeGlobal: input.adoption.includeGlobal,
+        sourceCount: input.adoption.sources.length,
+        presentedSourceCount: 0,
+        importedRuleCount: input.adoption.importedRules.length,
+        conflictCount: input.adoption.conflicts.length,
+        rejectedCount: input.adoption.rejected.length
+      }
+    });
+  }
+  return `${BOOTSTRAP_PROMPT}
+
+<bootstrap-input>
+${serialized}
+</bootstrap-input>`;
+}
+function extractJsonObject(text) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) return JSON.parse(trimmed);
+  const fenced = /```(?:json)?\s*([\s\S]*?)```/i.exec(trimmed)?.[1]?.trim();
+  if (fenced?.startsWith("{")) return JSON.parse(fenced);
+  const start = trimmed.indexOf("{");
+  const end = trimmed.lastIndexOf("}");
+  if (start >= 0 && end > start) return JSON.parse(trimmed.slice(start, end + 1));
+  throw new Error("bootstrap model output did not contain a JSON object");
+}
+function stringArray(value, key, maxItems, maxChars) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) throw new Error(`bootstrap model output '${key}' must be an array`);
+  return value.map((item, index) => {
+    if (typeof item !== "string") throw new Error(`bootstrap model output '${key}[${index}]' must be a string`);
+    return item.replace(/\s+/g, " ").trim();
+  }).filter((item) => item.length > 0).slice(0, maxItems).map((item) => item.slice(0, maxChars));
+}
+function stringField(record, key, maxChars) {
+  const value = record[key];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`bootstrap model output '${key}' must be a non-empty string`);
+  }
+  return value.replace(/\s+/g, " ").trim().slice(0, maxChars);
+}
+function structuredSections(value) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) throw new Error("bootstrap model output 'sections' must be an array");
+  return value.map((item, index) => {
+    if (typeof item !== "object" || item === null || Array.isArray(item)) {
+      throw new Error(`bootstrap model output 'sections[${index}]' must be an object`);
+    }
+    const record = item;
+    if (typeof record.title !== "string" || record.title.trim().length === 0) {
+      throw new Error(`bootstrap model output 'sections[${index}].title' must be a non-empty string`);
+    }
+    if (typeof record.body !== "string" || record.body.trim().length === 0) {
+      throw new Error(`bootstrap model output 'sections[${index}].body' must be a non-empty string`);
+    }
+    return {
+      title: record.title.replace(/\s+/g, " ").trim().slice(0, 80),
+      body: record.body.trim().slice(0, 2500)
+    };
+  }).filter((section) => section.title.length > 0 && section.body.length > 0).slice(0, 8);
+}
+function parseBootstrapModelOutput(text) {
+  const parsed = extractJsonObject(text);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("bootstrap model output must be a JSON object");
+  }
+  const record = parsed;
+  return {
+    projectName: stringField(record, "projectName", 80),
+    identity: stringField(record, "identity", 600),
+    conventions: stringArray(record.conventions, "conventions", 6, 200),
+    invariants: stringArray(record.invariants, "invariants", 3, 280),
+    sections: structuredSections(record.sections)
+  };
+}
+
+// src/cli/bootstrap-generate.ts
+var BOOTSTRAP_MAX_OUTPUT_BYTES = 256 * 1024;
+var CONTEXT_BOOTSTRAP_AGENT_ID = "context-bootstrap";
+function resolveBootstrapRoute(settings) {
+  for (const agentId of [CONTEXT_BOOTSTRAP_AGENT_ID, "scout"]) {
+    const profileName = settings.workers.agentBindings[agentId];
+    if (!profileName) continue;
+    const profile = settings.workers.profiles[profileName];
+    if (!profile) throw new Error(`bootstrap profile '${profileName}' is not configured (bound to '${agentId}')`);
+    if (!profile.target) throw new Error(`bootstrap profile '${profileName}' has no target (bound to '${agentId}')`);
+    return {
+      target: profile.target,
+      ...profile.model ? { model: profile.model } : {},
+      ...profile.thinkingLevel ? { thinkingLevel: profile.thinkingLevel } : {}
+    };
+  }
+  const fallback = settings.workers.default;
+  if (!fallback?.target) {
+    throw new Error(
+      `bootstrap has no route: workers.agentBindings.${CONTEXT_BOOTSTRAP_AGENT_ID} is unbound and workers.default has no target; bind a profile with 'clio-coder targets profile bind ${CONTEXT_BOOTSTRAP_AGENT_ID} <profile>' or set workers.default.target`
+    );
+  }
+  return {
+    target: fallback.target,
+    ...fallback.model ? { model: fallback.model } : {},
+    ...fallback.thinkingLevel ? { thinkingLevel: fallback.thinkingLevel } : {}
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assistantTextFromMessage(message) {
+  if (!isRecord(message) || message.role !== "assistant") return "";
+  const content = message.content;
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content.map((block) => {
+    if (typeof block === "string") return block;
+    if (!isRecord(block)) return "";
+    return typeof block.text === "string" ? block.text : "";
+  }).join("").trim();
+}
+function textDeltaFromEvent(event) {
+  if (!isRecord(event) || event.type !== "text_delta") return "";
+  return typeof event.text === "string" ? event.text : "";
+}
+function toolNameFromEvent(event) {
+  if (!isRecord(event)) return null;
+  const payload = event.payload;
+  if (!isRecord(payload)) return null;
+  return typeof payload.tool === "string" && payload.tool.length > 0 ? payload.tool : null;
+}
+function toolOutcomeFromEvent(event) {
+  if (!isRecord(event)) return null;
+  const payload = event.payload;
+  if (!isRecord(payload)) return null;
+  return typeof payload.outcome === "string" && payload.outcome.length > 0 ? payload.outcome : null;
+}
+var BootstrapAttemptError = class extends Error {
+  parserOutcome;
+  telemetry;
+  constructor(error, parserOutcome, telemetry) {
+    super(error.message);
+    this.name = "BootstrapAttemptError";
+    this.parserOutcome = parserOutcome;
+    this.telemetry = telemetry;
+  }
+};
+var BootstrapOutputLimitError = class extends Error {
+  constructor(observedBytes) {
+    super(`bootstrap output exceeded ${BOOTSTRAP_MAX_OUTPUT_BYTES} UTF-8 bytes`);
+    this.observedBytes = observedBytes;
+    this.name = "BootstrapOutputLimitError";
+  }
+  observedBytes;
+};
+function durationFromReceipt(receipt) {
+  const startedAt = Date.parse(receipt.startedAt);
+  const endedAt = Date.parse(receipt.endedAt);
+  if (!Number.isFinite(startedAt) || !Number.isFinite(endedAt)) return void 0;
+  return Math.max(0, endedAt - startedAt);
+}
+function bootstrapTelemetry(prompt, output, startedAt, structuredOutputMode, runId, receipt, observedOutputBytes) {
+  const telemetry = {
+    structuredOutputMode,
+    promptBytes: Buffer.byteLength(prompt, "utf8"),
+    outputBytes: observedOutputBytes ?? Buffer.byteLength(output, "utf8"),
+    durationMs: receipt ? durationFromReceipt(receipt) ?? Math.max(0, Date.now() - startedAt) : Math.max(0, Date.now() - startedAt),
+    ...runId ? { runId } : {}
+  };
+  if (!receipt) return telemetry;
+  telemetry.runId = receipt.runId;
+  telemetry.targetId = receipt.targetId;
+  telemetry.wireModelId = receipt.wireModelId;
+  telemetry.runtimeId = receipt.runtimeId;
+  telemetry.runtimeKind = receipt.runtimeKind;
+  if (receipt.runtimeResolution?.effectiveThinkingLevel) {
+    telemetry.thinkingLevel = receipt.runtimeResolution.effectiveThinkingLevel;
+  }
+  telemetry.tokens = {
+    total: receipt.tokenCount,
+    ...receipt.inputTokenCount !== void 0 ? { input: receipt.inputTokenCount } : {},
+    ...receipt.outputTokenCount !== void 0 ? { output: receipt.outputTokenCount } : {},
+    ...receipt.cacheReadTokenCount !== void 0 ? { cacheRead: receipt.cacheReadTokenCount } : {},
+    ...receipt.cacheWriteTokenCount !== void 0 ? { cacheWrite: receipt.cacheWriteTokenCount } : {},
+    ...receipt.reasoningTokenCount !== void 0 ? { reasoning: receipt.reasoningTokenCount } : {}
+  };
+  telemetry.toolCalls = receipt.toolCalls;
+  telemetry.toolFailures = receipt.toolStats.reduce((total, stat) => total + stat.errors, 0);
+  telemetry.toolBlocked = receipt.toolStats.reduce((total, stat) => total + stat.blocked, 0);
+  return telemetry;
+}
+async function collectDispatchAssistantText(events, input) {
+  let streamedText = "";
+  let streamedBytes = 0;
+  let lastAssistantText = "";
+  for await (const event of events) {
+    if (isRecord(event) && event.type === "route_warning" && typeof event.message === "string") {
+      input.progress?.({
+        phase: "generate",
+        status: "running",
+        message: "bootstrap routing changed",
+        detail: event.message
+      });
+    }
+    if (isRecord(event) && event.type === "agent_start") {
+      input.progress?.({
+        phase: "generate",
+        status: "running",
+        message: "bootstrap agent started repository exploration"
+      });
+    }
+    if (isRecord(event) && event.type === "clio_tool_start") {
+      const tool = toolNameFromEvent(event);
+      if (tool) {
+        input.progress?.({
+          phase: "generate",
+          status: "running",
+          message: `bootstrap running ${tool}`,
+          detail: "read-only repository exploration"
+        });
+      }
+    }
+    if (isRecord(event) && event.type === "clio_tool_finish") {
+      const tool = toolNameFromEvent(event);
+      const outcome = toolOutcomeFromEvent(event) ?? "done";
+      if (tool) {
+        input.progress?.({
+          phase: "generate",
+          status: "running",
+          message: `bootstrap ${tool} ${outcome}`
+        });
+      }
+    }
+    const delta = textDeltaFromEvent(event);
+    if (delta.length > 0) {
+      streamedBytes += Buffer.byteLength(delta, "utf8");
+      if (streamedBytes > BOOTSTRAP_MAX_OUTPUT_BYTES) {
+        throw new BootstrapOutputLimitError(streamedBytes);
+      }
+      streamedText += delta;
+    }
+    if (isRecord(event) && event.type === "message_end") {
+      const text = assistantTextFromMessage(event.message);
+      if (text.length > 0) {
+        const bytes = Buffer.byteLength(text, "utf8");
+        if (bytes > BOOTSTRAP_MAX_OUTPUT_BYTES) throw new BootstrapOutputLimitError(bytes);
+        lastAssistantText = text;
+      }
+    }
+  }
+  return (lastAssistantText || streamedText).trim();
+}
+function receiptFailure(receipt) {
+  const detail = receipt.failureMessage ? `: ${receipt.failureMessage}` : "";
+  return `bootstrap agent failed with exit ${receipt.exitCode}${detail}`;
+}
+function responseSchemaRefusal(err) {
+  if (err instanceof UnsupportedResponseSchemaError) return err.message;
+  if (err instanceof BootstrapAttemptError && isResponseSchemaRejection(err.message)) return err.message;
+  return null;
+}
+async function attemptBootstrapDispatch(dispatch, input, prompt, startedAt, structuredOutputMode, dispatchBootstrap) {
+  const nativeSchema = structuredOutputMode === "native-schema";
+  let handle;
+  try {
+    handle = await dispatchBootstrap(nativeSchema);
+  } catch (err) {
+    if (nativeSchema && err instanceof UnsupportedResponseSchemaError) throw err;
+    const error = err instanceof Error ? err : new Error(String(err));
+    throw new BootstrapAttemptError(error, "not-run", bootstrapTelemetry(prompt, "", startedAt, structuredOutputMode));
+  }
+  const deadline = armInternalDispatchDeadline(dispatch, handle.runId, "context bootstrap", process.env);
+  let text = "";
+  let receipt;
+  let parserAttempted = false;
+  try {
+    text = await collectDispatchAssistantText(handle.events, input);
+    receipt = await handle.finalPromise;
+    if (deadline.timedOut()) throw new Error(deadline.message());
+    if (receipt.exitCode !== 0) throw new Error(receiptFailure(receipt));
+    if (text.length === 0) throw new Error("bootstrap agent did not return an assistant response");
+    parserAttempted = true;
+    const output = parseBootstrapModelOutput(text);
+    input.progress?.({
+      phase: "generate",
+      status: "running",
+      message: "bootstrap agent returned the handbook payload",
+      detail: `${Buffer.byteLength(text, "utf8")} bytes`
+    });
+    input.reportGeneration?.({
+      mode: "model",
+      parserOutcome: "parsed",
+      run: bootstrapTelemetry(prompt, text, startedAt, structuredOutputMode, handle.runId, receipt)
+    });
+    return output;
+  } catch (err) {
+    if (!deadline.timedOut()) dispatch.abort(handle.runId);
+    receipt ??= await handle.finalPromise.catch(() => void 0);
+    const error = deadline.timedOut() ? new Error(deadline.message()) : err instanceof Error ? err : new Error(String(err));
+    throw new BootstrapAttemptError(
+      error,
+      parserAttempted ? "rejected" : "not-run",
+      bootstrapTelemetry(
+        prompt,
+        text,
+        startedAt,
+        structuredOutputMode,
+        handle.runId,
+        receipt,
+        err instanceof BootstrapOutputLimitError ? err.observedBytes : void 0
+      )
+    );
+  } finally {
+    deadline.clear();
+  }
+}
+async function generateBootstrapWithModel(dispatch, input, route) {
+  const prompt = buildBootstrapPrompt(input);
+  const startedAt = Date.now();
+  input.progress?.({
+    phase: "generate",
+    status: "running",
+    message: "dispatching internal context-bootstrap agent",
+    detail: `agent=${CONTEXT_BOOTSTRAP_AGENT_ID}`
+  });
+  const dispatchBootstrap = (nativeSchema) => dispatch.dispatch({
+    agentId: CONTEXT_BOOTSTRAP_AGENT_ID,
+    executionRole: "researcher",
+    task: prompt,
+    cwd: input.cwd,
+    requestOrigin: "internal",
+    thinkingLevel: route?.thinkingLevel ?? "off",
+    noSkills: true,
+    ...nativeSchema ? { responseSchema: BOOTSTRAP_OUTPUT_JSON_SCHEMA } : {},
+    ...route ? { target: route.target } : {},
+    ...route?.model ? { model: route.model } : {}
+  });
+  try {
+    return await attemptBootstrapDispatch(dispatch, input, prompt, startedAt, "native-schema", dispatchBootstrap);
+  } catch (err) {
+    const refusal = responseSchemaRefusal(err);
+    if (refusal === null) throw err;
+    input.progress?.({
+      phase: "generate",
+      status: "running",
+      message: "native schema unavailable; using bounded output parser",
+      detail: refusal
+    });
+    return await attemptBootstrapDispatch(dispatch, input, prompt, startedAt, "prompt-parser", dispatchBootstrap);
+  }
+}
+async function loadBootstrapDispatch() {
+  const loaded = await loadDomains([
+    ConfigDomainModule,
+    ResourcesDomainModule,
+    ProvidersDomainModule,
+    SafetyDomainModule,
+    createPromptsDomainModule({ noContextFiles: true }),
+    AgentsDomainModule,
+    MiddlewareDomainModule,
+    SessionDomainModule,
+    // Same shape as the wiki writer: one internal dispatch in a process that
+    // exits with it. The SQLite mirror opens `node:sqlite` on the first
+    // dispatch event, which costs `clio-coder context init` a module load it never
+    // reads back and prints Node's ExperimentalWarning over the command's own
+    // output. Receipts and the ledger still record the run.
+    createObservabilityDomainModule({ dispatchTrace: false }),
+    SchedulingDomainModule,
+    DispatchDomainModule
+  ]);
+  const dispatch = loaded.getContract("dispatch");
+  const config = loaded.getContract("config");
+  if (!dispatch || !config) {
+    await loaded.stop();
+    throw new Error("bootstrap dispatch or configuration unavailable");
+  }
+  return { dispatch, config, loaded };
+}
+function modelBootstrapGenerate(options = {}) {
+  return async (input) => {
+    let loaded = null;
+    try {
+      if (options.dispatch) {
+        const route = options.route ?? options.resolveRoute?.();
+        return await generateBootstrapWithModel(options.dispatch, input, route);
+      }
+      {
+        const lazy = await loadBootstrapDispatch();
+        loaded = lazy.loaded;
+        const route = options.route ?? resolveBootstrapRoute(lazy.config.get());
+        return await generateBootstrapWithModel(lazy.dispatch, input, route);
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      const fallback = fallbackBootstrapOutput(input);
+      const generation = {
+        mode: fallback.mode,
+        parserOutcome: err instanceof BootstrapAttemptError ? err.parserOutcome : "not-run",
+        fallbackReason: error.message,
+        ...err instanceof BootstrapAttemptError ? { run: err.telemetry } : {}
+      };
+      input.progress?.({
+        phase: "generate",
+        status: "running",
+        message: fallback.mode === "existing" ? "bootstrap agent unavailable; preserving existing CLIO-CODER.md" : "bootstrap agent unavailable; using heuristic bootstrap",
+        detail: error.message
+      });
+      input.reportGeneration?.(generation);
+      options.onFallback?.(error, fallback.mode);
+      return fallback.output;
+    } finally {
+      if (loaded) await loaded.stop();
+    }
+  };
+}
+
+// src/domains/context/init-options.ts
+var CONTEXT_INIT_FLAG_TABLE = [
+  { flag: "--preview", field: "preview" },
+  { flag: "--adopt", field: "adopt" },
+  { flag: "--apply", field: "applyClioMd" },
+  { flag: "--rewrite", field: "rewriteClioMd" },
+  { flag: "--propose", field: "proposeClioMd" },
+  { flag: "--global", aliases: ["--include-global"], field: "includeGlobalImports" },
+  { flag: "--heuristic", field: "heuristic" }
+];
+function applyInitImplications(options) {
+  if (options.applyClioMd === true || options.rewriteClioMd === true) {
+    return { ...options, applyClioMd: true };
+  }
+  return { ...options };
+}
+function validateInitOptions(options) {
+  if (options.proposeClioMd === true && (options.adopt === true || options.applyClioMd === true || options.rewriteClioMd === true)) {
+    return "clio-coder context init: --propose cannot be combined with --adopt, --apply, or --rewrite";
+  }
+  return null;
+}
+function bootstrapInputFromInitOptions(options) {
+  const implied = applyInitImplications(options);
+  const input = {};
+  for (const field of [
+    "preview",
+    "adopt",
+    "applyClioMd",
+    "rewriteClioMd",
+    "proposeClioMd",
+    "includeGlobalImports"
+  ]) {
+    if (implied[field] !== void 0) {
+      input[field] = implied[field];
+    }
+  }
+  return input;
+}
+
+export {
+  resolveBootstrapRoute,
+  modelBootstrapGenerate,
+  CONTEXT_INIT_FLAG_TABLE,
+  validateInitOptions,
+  bootstrapInputFromInitOptions
+};
+//# sourceMappingURL=chunk-O4EJEDHO.js.map

package/dist/chunk-PIDUD6M2.js

@@ -0,0 +1,31 @@
+import {
+  printError
+} from "./chunk-67MTHP2E.js";
+import {
+  authStoragePath
+} from "./chunk-5LDRNKX2.js";
+
+// src/cli/shared.ts
+import chalk from "chalk";
+function printPlaintextCredentialWarning() {
+  process.stderr.write(
+    `${chalk.yellow("warning:")} API key stored unencrypted at ${authStoragePath()} (mode 0600).
+  It is readable by any process running as you. To keep the key off disk, configure the
+  target with an environment variable instead: clio-coder configure ... --api-key-env <VAR>.
+`
+  );
+}
+function credentialWriteFailed(auth, subject) {
+  const damage = auth.damageReason();
+  if (damage === null) return false;
+  printError(`${subject}: ${damage}`);
+  process.stderr.write(`  ${authStoragePath()} is unchanged.
+`);
+  return true;
+}
+
+export {
+  printPlaintextCredentialWarning,
+  credentialWriteFailed
+};
+//# sourceMappingURL=chunk-PIDUD6M2.js.map