@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-ALJWT6O6.js

@@ -0,0 +1,93 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/engine/env-api-keys.ts
+init_esm_shims();
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var ANTHROPIC_AUTH_TOKEN_ENV = "ANTHROPIC_AUTH_TOKEN";
+var ANTHROPIC_OAUTH_TOKEN_ENV = "ANTHROPIC_OAUTH_TOKEN";
+var ANTHROPIC_API_KEY_ENV = "ANTHROPIC_API_KEY";
+var ENV_KEYS = {
+  "ant-ling": "ANT_LING_API_KEY",
+  "qwen-token-plan": "QWEN_TOKEN_PLAN_API_KEY",
+  "qwen-token-plan-cn": "QWEN_TOKEN_PLAN_CN_API_KEY",
+  "qwen-token-plan-individual": "QWEN_TOKEN_PLAN_API_KEY",
+  openai: "OPENAI_API_KEY",
+  meta: "META_API_KEY",
+  "azure-openai-responses": "AZURE_OPENAI_API_KEY",
+  nvidia: "NVIDIA_API_KEY",
+  deepseek: "DEEPSEEK_API_KEY",
+  google: "GEMINI_API_KEY",
+  "google-vertex": "GOOGLE_CLOUD_API_KEY",
+  groq: "GROQ_API_KEY",
+  cerebras: "CEREBRAS_API_KEY",
+  xai: "XAI_API_KEY",
+  radius: "RADIUS_API_KEY",
+  openrouter: "OPENROUTER_API_KEY",
+  "vercel-ai-gateway": "AI_GATEWAY_API_KEY",
+  zai: "ZAI_API_KEY",
+  "zai-coding-cn": "ZAI_CODING_CN_API_KEY",
+  mistral: "MISTRAL_API_KEY",
+  minimax: "MINIMAX_API_KEY",
+  "minimax-cn": "MINIMAX_CN_API_KEY",
+  moonshotai: "MOONSHOT_API_KEY",
+  "moonshotai-cn": "MOONSHOT_API_KEY",
+  huggingface: "HF_TOKEN",
+  fireworks: "FIREWORKS_API_KEY",
+  together: "TOGETHER_API_KEY",
+  baseten: "BASETEN_API_KEY",
+  opencode: "OPENCODE_API_KEY",
+  "opencode-go": "OPENCODE_API_KEY",
+  "kimi-coding": "KIMI_API_KEY",
+  "cloudflare-workers-ai": "CLOUDFLARE_API_KEY",
+  "cloudflare-ai-gateway": "CLOUDFLARE_API_KEY",
+  xiaomi: "XIAOMI_API_KEY",
+  "xiaomi-token-plan-cn": "XIAOMI_TOKEN_PLAN_CN_API_KEY",
+  "xiaomi-token-plan-ams": "XIAOMI_TOKEN_PLAN_AMS_API_KEY",
+  "xiaomi-token-plan-sgp": "XIAOMI_TOKEN_PLAN_SGP_API_KEY"
+};
+function envValue(name, env) {
+  return env?.[name] || process.env[name] || void 0;
+}
+function apiKeyEnvVars(provider) {
+  if (provider === "github-copilot") return ["COPILOT_GITHUB_TOKEN"];
+  if (provider === "anthropic") {
+    return [ANTHROPIC_AUTH_TOKEN_ENV, ANTHROPIC_OAUTH_TOKEN_ENV, ANTHROPIC_API_KEY_ENV];
+  }
+  const name = ENV_KEYS[provider];
+  return name ? [name] : void 0;
+}
+function findEngineEnvKeys(provider, env) {
+  const names = apiKeyEnvVars(provider);
+  if (!names) return void 0;
+  const found = names.filter((name) => !!envValue(name, env));
+  return found.length > 0 ? found : void 0;
+}
+function getEngineEnvApiKey(provider, env) {
+  const keys = findEngineEnvKeys(provider, env);
+  if (keys?.[0]) {
+    const name = provider === "anthropic" ? keys.find((key) => key !== ANTHROPIC_AUTH_TOKEN_ENV) : keys[0];
+    if (name) return envValue(name, env);
+  }
+  if (provider === "google-vertex") {
+    const credentialsPath = envValue("GOOGLE_APPLICATION_CREDENTIALS", env);
+    const hasCredentials = credentialsPath ? existsSync(credentialsPath) : existsSync(join(homedir(), ".config", "gcloud", "application_default_credentials.json"));
+    const hasProject = !!(envValue("GOOGLE_CLOUD_PROJECT", env) || envValue("GCLOUD_PROJECT", env));
+    const hasLocation = !!envValue("GOOGLE_CLOUD_LOCATION", env);
+    if (hasCredentials && hasProject && hasLocation) return "<authenticated>";
+  }
+  if (provider === "amazon-bedrock" && (envValue("AWS_PROFILE", env) || envValue("AWS_ACCESS_KEY_ID", env) && envValue("AWS_SECRET_ACCESS_KEY", env) || envValue("AWS_BEARER_TOKEN_BEDROCK", env) || envValue("AWS_CONTAINER_CREDENTIALS_RELATIVE_URI", env) || envValue("AWS_CONTAINER_CREDENTIALS_FULL_URI", env) || envValue("AWS_WEB_IDENTITY_TOKEN_FILE", env))) {
+    return "<authenticated>";
+  }
+  return void 0;
+}
+
+export {
+  findEngineEnvKeys,
+  getEngineEnvApiKey
+};
+//# sourceMappingURL=chunk-ALJWT6O6.js.map

package/dist/chunk-AVSR2HKI.js

@@ -0,0 +1,232 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  receiptGatewayRoutingLabel,
+  receiptResponseModelIdObservationLabel
+} from "./chunk-LTWH2ACR.js";
+import {
+  formatTrustAxes,
+  formatTrustSummary
+} from "./chunk-OZ76TLGU.js";
+import {
+  adaptRunReceiptTrustStatus
+} from "./chunk-VKHLUZNO.js";
+import {
+  formatBudgetPolicy,
+  formatBudgetReasons,
+  formatBudgetRequest,
+  formatEffectiveBudget
+} from "./chunk-OQ2EOAHA.js";
+import {
+  truncateUtf8
+} from "./chunk-MYI32N4R.js";
+import {
+  RESULT_SUMMARY_MAX_BYTES_CEILING,
+  resultContractAuthorship
+} from "./chunk-LNOXCGN2.js";
+import {
+  mentionsWorkerToolCallCap
+} from "./chunk-C27U2TYG.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/tools/worker-evidence.ts
+init_esm_shims();
+function receiptHelperResult(receipt, integrity) {
+  const output = receipt.output;
+  if (!integrity.ok || receipt.exitCode !== 0 || receipt.outcome !== "succeeded" || output?.state !== "final" || output.truncated || receipt.quality?.resultContract?.conformance !== "pass")
+    return null;
+  return output.structured ?? null;
+}
+function compactHelperResultLines(receipt, integrity, maxBytes) {
+  const result = receiptHelperResult(receipt, integrity);
+  if (result === null) return null;
+  const quality = receipt.quality?.resultContract?.quality ?? "unmeasured";
+  return [
+    `- ${receipt.agentId} \xB7 run ${receipt.runId} \xB7 ${result.kind} \xB7 quality=${quality}`,
+    ...quality !== "pass" ? [
+      result.kind === "scout-report" ? "  Findings without path and line are ungrounded leads; do not present them as verified facts." : "  Content is contract-valid; its factual accuracy is unmeasured."
+    ] : [],
+    `  ${truncateUtf8(JSON.stringify(result.data), maxBytes, "\n[helper result preview truncated; inspect the receipt for the full result]")}`,
+    `  Receipt available on demand: monitor(mode="receipt", run_id=${JSON.stringify(receipt.runId)}).`
+  ];
+}
+var SOURCE_CITATION_PATTERN = /([\w./~-]+):(\d+)/g;
+function sourceCitations(text) {
+  const citations = [];
+  for (const match of text.matchAll(SOURCE_CITATION_PATTERN)) {
+    const path = match[1];
+    const line = Number(match[2]);
+    if (path && Number.isSafeInteger(line) && line > 0) citations.push({ path, line });
+  }
+  return citations;
+}
+function hasSourceCitation(text) {
+  return sourceCitations(text).length > 0;
+}
+var SPOT_CHECK_GUIDANCE = 'Spot-check delegated claims before repeating them: re-read any cited file:line location, and re-run or inspect the named validation before repeating a "tests pass" claim.';
+function isMutationClassRun(receipt, status) {
+  if (status.validationGrounding.state === "not_applicable") return false;
+  if (receipt.executionRole === "builder" || receipt.executionRole === "recovery") return true;
+  return receipt.quality?.resultContract?.sourceId?.startsWith("agent-result-contract:mutation-report") === true;
+}
+function receiptAdmissionLabels(receipt) {
+  const labels = [];
+  const mismatch = receipt.capabilityMismatch;
+  if (mismatch !== void 0) {
+    labels.push(
+      `capability_mismatch=${mismatch.capabilityClass}/${mismatch.taskType}${mismatch.suggestedAgentId === null ? "" : ` suggested:${mismatch.suggestedAgentId}`}`
+    );
+  }
+  const grounding = receipt.validationGrounding;
+  if (grounding !== void 0) {
+    labels.push(
+      `validations=claimed:${grounding.claimed} grounded:${grounding.grounded}${grounding.ungrounded.length > 0 ? ` ${grounding.basis === "no-command-executed" ? "unverifiable" : "unmatched"}:${grounding.ungrounded.map((name) => JSON.stringify(name)).join(",")}` : ""}`
+    );
+  }
+  return labels;
+}
+function receiptActivityLabels(receipt, status) {
+  const labels = [];
+  const activity = receipt.toolActivity;
+  if (activity !== void 0) {
+    labels.push(
+      `work=calls:${activity.calls} ok:${activity.succeeded} failed:${activity.failed} blocked:${activity.blocked} mutations:${activity.mutatingSucceeded ? "yes" : "no"}`
+    );
+    if (!activity.mutatingSucceeded && isMutationClassRun(receipt, status)) labels.push("mutation_effect=none");
+  }
+  const findings = receipt.findingsSummary;
+  if (findings !== void 0) {
+    if (!findings.firstPassSuccess) labels.push("first_pass=false");
+    if (findings.tags.length > 0) labels.push(`findings=${[...findings.tags].sort().join(",")}`);
+  }
+  return labels;
+}
+function receiptEvidenceLabels(receipt, verification, integrity) {
+  const status = adaptRunReceiptTrustStatus({ ...receipt, verification }, { integrity });
+  const canonical = canonicalTrustLabels(status);
+  if (!integrity.ok) {
+    return [...canonical, `receipt_integrity=FAILED reason=${JSON.stringify(integrity.reason)}`];
+  }
+  const briefing = receipt.briefing === void 0 ? "briefing=none" : `briefing=bytes:${receipt.briefing.bytes} sha256:${receipt.briefing.contentHash}`;
+  let projectContext = "project_context=absent";
+  if (receipt.projectContext !== void 0) {
+    const sections = receipt.projectContext.sections ?? [];
+    projectContext = `project_context=${receipt.projectContext.tier} chars:${receipt.projectContext.chars ?? 0}${sections.length > 0 ? ` sections:${[...sections].sort().join(",")}` : ""}${receipt.projectContext.contentHash !== void 0 ? ` sha256:${receipt.projectContext.contentHash}` : ""}`;
+  }
+  const responseModelIdObservation = receiptResponseModelIdObservationLabel(receipt);
+  const gatewayRouting = receiptGatewayRoutingLabel(receipt);
+  const budget = receipt.budget === void 0 ? [] : [
+    `budget_recipe_policy=${JSON.stringify(formatBudgetPolicy(receipt.budget))}`,
+    `budget_requested=${JSON.stringify(formatBudgetRequest(receipt.budget))}`,
+    `budget_effective=${JSON.stringify(formatEffectiveBudget(receipt.budget))}`,
+    `budget_reason=${JSON.stringify(formatBudgetReasons(receipt.budget))}`
+  ];
+  return [
+    ...canonical,
+    `receipt_integrity=verified/v${receipt.integrity.version}/${receipt.integrity.algorithm}`,
+    ...documenterDeliveryLabels(receipt),
+    `evidence_verification=${verification.state}/${verification.basis}`,
+    `host_verification=${receipt.hostVerification?.status ?? "not_requested"}`,
+    ...receipt.hostVerification?.checks.length ? [
+      `Host check evidence is separate from the worker report: ${receipt.hostVerification.checks.map((check) => {
+        const source = check.memo ? "reused prior host result" : receipt.hostVerification?.strategy === "batch-settled" ? "executed after the worker batch" : "executed after the worker";
+        return `${JSON.stringify(check.check)} (${source}; exit ${check.exitCode})`;
+      }).join(", ")}.`
+    ] : [],
+    ...responseModelIdObservation ? [responseModelIdObservation] : [],
+    ...gatewayRouting ? [gatewayRouting] : [],
+    ...budget,
+    ...receiptAdmissionLabels(receipt),
+    ...receiptActivityLabels(receipt, status),
+    briefing,
+    ...receipt.workerContext ? [
+      `context=${receipt.workerContext.mode} tokens:${receipt.workerContext.estimatedTokens} omitted:${receipt.workerContext.omittedMessages} sha256:${receipt.workerContext.contentHash}`
+    ] : [],
+    projectContext
+  ];
+}
+function documenterDeliveryLabels(receipt) {
+  if (receipt.agentId !== "documenter" || !receipt.quality.resultContract?.sourceId.startsWith("agent-result-contract:mutation-report:"))
+    return [];
+  const output = receipt.output;
+  const summary = output?.state === "final" ? resultContractAuthorship(
+    { kind: "mutation-report", maxSummaryBytes: RESULT_SUMMARY_MAX_BYTES_CEILING },
+    output.text
+  ).summary : null;
+  return [
+    `terminal Documenter result: ${summary === null ? "no inline summary is available" : "the inline deliverable or limitation is in output.text JSON field summary"}. Execution success and contract conformance alone do not prove the requested explanation was delivered.`,
+    "Read the summary or the task-authorized artifact once and check it against the requested deliverable. If it is absent, incomplete, or states a limitation, report the specific limitation and the run ID; do not repeatedly read this unchanged terminal receipt or poll it for new output. Keep any separately authorized recovery and its outcome distinct from the original run."
+  ];
+}
+function canonicalTrustLabels(status) {
+  return [`trust=${JSON.stringify(formatTrustSummary(status))}`, formatTrustAxes(status)];
+}
+function workerTextLabel(status) {
+  switch (status.validationGrounding.state) {
+    case "validated":
+      return "worker output (tool-verified):";
+    case "not_applicable":
+      return "reconnaissance output (advisory leads, not validation evidence):";
+    case "unknown":
+      return "worker claims (validation not observable at this layer):";
+    // The three remaining states were one label. The evidence bundle tells
+    // a failed check, an inferred claim, and no validation at all apart, so
+    // the terminal must too or it hands the operator a coarser verdict than
+    // the report for the same run.
+    case "failed":
+      return "worker claims (validation failed; a check ran and did not pass):";
+    case "ungrounded":
+      return "worker claims (inferred; validation claimed, none observed):";
+    default:
+      return "worker claims (unverified prose):";
+  }
+}
+function workerTextNonEvidenceNotices(receipt, status, answerText) {
+  const notices = [];
+  const failedRun = receipt.exitCode !== 0 || receipt.outcome !== void 0 && receipt.outcome !== "succeeded";
+  if (mentionsWorkerToolCallCap(receipt.failureMessage) || mentionsWorkerToolCallCap(receipt.outcomeDetail)) {
+    notices.push(
+      answerText.length > 0 ? "non-evidence: the worker exhausted its tool-call cap; the text above is a partial synthesis, not verified results." : "non-evidence: the worker exhausted its tool-call cap before a final synthesis was captured."
+    );
+  } else if (failedRun) {
+    notices.push(
+      "non-evidence: this run did not succeed; treat the text above as an unsubstantiated report, not results."
+    );
+  }
+  if (receipt.toolActivity !== void 0 && receipt.toolActivity.succeeded === 0) {
+    notices.push("non-evidence: no tool call succeeded in this run; the text above was written without observed work.");
+  } else if (receipt.toolActivity?.mutatingSucceeded === false && isMutationClassRun(receipt, status)) {
+    notices.push(
+      "non-evidence: this run was dispatched as work that changes the tree, but no mutating tool call succeeded. Nothing was written. Confirm with a diff before repeating any claim that something was fixed."
+    );
+  }
+  const grounding = receipt.validationGrounding;
+  if (grounding !== void 0 && grounding.ungrounded.length > 0) {
+    const named = grounding.ungrounded.map((name) => JSON.stringify(name)).join(", ");
+    notices.push(
+      grounding.basis === "no-command-executed" ? `non-evidence: this run reported ${named} as passing and executed no command at all. Re-run the check yourself before repeating the claim.` : `non-evidence: this run reported ${named} as passing through a command the harness cannot identify as that check. Re-run it before repeating the claim.`
+    );
+  }
+  if (receipt.capabilityMismatch !== void 0) {
+    notices.push(
+      `non-evidence: '${receipt.capabilityMismatch.agentId}' is a ${receipt.capabilityMismatch.capabilityClass} recipe and cannot write to the workspace, but this task classified as ${receipt.capabilityMismatch.taskType}. Nothing it reports as changed can have been changed by it.`
+    );
+  }
+  if (!failedRun && status.validationGrounding.state === "not_applicable" && answerText.length > 0 && !hasSourceCitation(answerText)) {
+    notices.push(
+      "non-evidence: this reconnaissance answer cites no file:line locations; treat its leads as unconfirmed."
+    );
+  }
+  return notices;
+}
+
+export {
+  receiptHelperResult,
+  compactHelperResultLines,
+  SPOT_CHECK_GUIDANCE,
+  receiptEvidenceLabels,
+  workerTextLabel,
+  workerTextNonEvidenceNotices
+};
+//# sourceMappingURL=chunk-AVSR2HKI.js.map

package/dist/chunk-B7GY6QER.js

@@ -0,0 +1,42 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  StringEnum
+} from "./chunk-L7G7K4I2.js";
+import {
+  ToolNames
+} from "./chunk-V4XJWDHR.js";
+import {
+  typebox_exports
+} from "./chunk-GH5ZR6JP.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/tools/monitor-surface.ts
+init_esm_shims();
+var monitorToolSurface = {
+  name: ToolNames.Monitor,
+  description: "Inspect dispatched runs: list enumerates them; status, peek, receipt, and tools observe one run; wait blocks on one run without collecting; collect is the terminal operation for a detached batch or run list, required before final synthesis.",
+  parameters: typebox_exports.Object({
+    run_id: typebox_exports.Optional(
+      typebox_exports.String({ description: "Run id from dispatch output or monitor list; omit with mode=list." })
+    ),
+    mode: typebox_exports.Optional(
+      StringEnum(["status", "peek", "receipt", "list", "wait", "collect", "tools"], {
+        description: "Defaults to status with run_id and list without. tools lists a run's tool calls with outcomes and per-tool totals."
+      })
+    ),
+    batch_id: typebox_exports.Optional(typebox_exports.String({ description: "Detached batch id (mode=collect)." })),
+    run_ids: typebox_exports.Optional(typebox_exports.Array(typebox_exports.String(), { description: "Run ids to collect (mode=collect)." })),
+    timeout_ms: typebox_exports.Optional(
+      typebox_exports.Number({ description: "mode=wait: max ms to block (default 60000, max 600000); collect never blocks." })
+    )
+  }),
+  baseActionClass: "read",
+  executionMode: "parallel"
+};
+
+export {
+  monitorToolSurface
+};
+//# sourceMappingURL=chunk-B7GY6QER.js.map

package/dist/chunk-BFOSV5EZ.js

@@ -0,0 +1,178 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  estimateInputTokensFromContext
+} from "./chunk-EYTLV3W3.js";
+import {
+  normalizeContext,
+  streamSimple
+} from "./chunk-L7G7K4I2.js";
+import {
+  clioStateDir
+} from "./chunk-CTTI7G3T.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/engine/prewarm.ts
+init_esm_shims();
+import {
+  createInitialSystemMessage,
+  getCurrentTools,
+  getToolStateChanges,
+  toToolDeclaration
+} from "@earendil-works/pi-ai";
+var PREWARM_USER_TEXT = ".";
+var PREWARM_MAX_TOKENS = 1;
+var LLM_MESSAGE_ROLES = /* @__PURE__ */ new Set(["system", "user", "assistant", "toolResult"]);
+function usageOf(message) {
+  if (message === null || typeof message !== "object") return null;
+  const usage = message.usage;
+  if (usage === null || typeof usage !== "object") return null;
+  const record = usage;
+  return [record.input, record.output, record.cacheRead, record.cacheWrite, record.cost?.total].some(
+    (value) => typeof value === "number" && Number.isFinite(value) && value > 0
+  ) ? record : null;
+}
+function backendOf(message) {
+  if (message === null || typeof message !== "object") return null;
+  const backend = message.backendTimings;
+  return backend !== null && typeof backend === "object" ? backend : null;
+}
+function prewarmPromptTokens(result) {
+  if (result.backend) return result.backend.promptTokens;
+  const usage = result.usage;
+  if (!usage) return null;
+  const total = (usage.input || 0) + (usage.cacheRead || 0) + (usage.cacheWrite || 0);
+  return total > 0 ? total : null;
+}
+async function runPrewarmRound(input) {
+  const options = { maxTokens: PREWARM_MAX_TOKENS };
+  const metadata = input.model.clioCoder;
+  const model = metadata ? { ...input.model, clioCoder: { ...metadata, lifecycle: "user-managed" } } : input.model;
+  if (metadata?.runtimeId === "llamacpp") {
+    options.fetch = (request, init) => {
+      const url = new URL(request instanceof Request ? request.url : request);
+      url.searchParams.set("autoload", "false");
+      return fetch(request instanceof Request ? new Request(url, request) : url, init);
+    };
+  }
+  if (input.state.thinkingLevel !== "off") options.reasoning = input.state.thinkingLevel;
+  if (input.apiKey !== void 0) options.apiKey = input.apiKey;
+  if (input.signal !== void 0) options.signal = input.signal;
+  if (input.agent) {
+    for (const key of [
+      "onPayload",
+      "onResponse",
+      "sessionId",
+      "thinkingBudgets",
+      "transport",
+      "maxRetryDelayMs"
+    ]) {
+      if (input.agent[key] !== void 0) options[key] = input.agent[key];
+    }
+  }
+  if (metadata?.runtimeId === "litellm") {
+    const onPayload = input.agent?.onPayload;
+    options.onPayload = async (payload, currentModel) => {
+      const patched = await onPayload?.(payload, currentModel) ?? payload;
+      return { ...patched, num_retries: 0, disable_fallbacks: true };
+    };
+  }
+  const send = input.streamFn ?? input.agent?.streamFunction ?? streamSimple;
+  const startedAt = performance.now();
+  let firstDeltaAt = null;
+  const elapsed = () => Math.round(Math.max(0, performance.now() - startedAt));
+  const ttft = () => firstDeltaAt === null ? null : Math.round(Math.max(0, firstDeltaAt - startedAt));
+  try {
+    input.signal?.throwIfAborted();
+    let messages = structuredClone([...input.state.messages]);
+    if (messages[0]?.role !== "system") {
+      const initial = createInitialSystemMessage(input.state.systemPrompt, input.state.tools.map(toToolDeclaration));
+      if (initial) messages.unshift(initial);
+    }
+    const changes = getToolStateChanges(getCurrentTools(messages), input.state.tools.map(toToolDeclaration));
+    if (changes.toolsAdded.length || changes.toolsRemoved.length) {
+      messages.push({
+        role: "system",
+        content: "",
+        timestamp: Date.now(),
+        ...changes.toolsAdded.length ? { toolsAdded: changes.toolsAdded } : {},
+        ...changes.toolsRemoved.length ? { toolsRemoved: changes.toolsRemoved } : {}
+      });
+    }
+    messages.push({ role: "user", content: [{ type: "text", text: PREWARM_USER_TEXT }], timestamp: Date.now() });
+    if (input.agent?.transformContext) messages = await input.agent.transformContext(messages, input.signal);
+    const converted = input.agent ? await input.agent.convertToLlm(messages) : messages.filter((message) => LLM_MESSAGE_ROLES.has(message.role));
+    input.signal?.throwIfAborted();
+    const context = normalizeContext({ messages: converted });
+    if (input.maxInputTokens !== void 0 && estimateInputTokensFromContext(context) > input.maxInputTokens) {
+      throw new Error("pre-warm input estimate exceeds its token budget");
+    }
+    if (input.canSend?.() === false) {
+      return { aborted: true, usage: null, backend: null, timing: { ttftMs: null, apiMs: elapsed() }, errorMessage: null };
+    }
+    const events = await send(model, context, options);
+    for await (const event of events) {
+      const hasDelta = event.type === "toolcall_start" || (event.type === "text_delta" || event.type === "thinking_delta" || event.type === "toolcall_delta") && event.delta.length > 0;
+      if (firstDeltaAt === null && hasDelta) firstDeltaAt = performance.now();
+      if (event.type === "done") {
+        return {
+          aborted: false,
+          usage: usageOf(event.message),
+          backend: backendOf(event.message),
+          timing: { ttftMs: ttft(), apiMs: elapsed() },
+          errorMessage: null
+        };
+      }
+      if (event.type === "error") {
+        const failed = event.error;
+        const aborted = event.reason === "aborted" || failed.stopReason === "aborted" || input.signal?.aborted === true;
+        return {
+          aborted,
+          usage: usageOf(event.error),
+          backend: backendOf(event.error),
+          timing: { ttftMs: ttft(), apiMs: elapsed() },
+          errorMessage: aborted ? null : typeof failed.errorMessage === "string" ? failed.errorMessage : "pre-warm failed"
+        };
+      }
+    }
+  } catch (error) {
+    return {
+      aborted: input.signal?.aborted === true,
+      usage: null,
+      backend: null,
+      timing: { ttftMs: ttft(), apiMs: elapsed() },
+      errorMessage: input.signal?.aborted === true ? null : error instanceof Error ? error.message : String(error)
+    };
+  }
+  return {
+    aborted: input.signal?.aborted === true,
+    usage: null,
+    backend: null,
+    timing: { ttftMs: ttft(), apiMs: elapsed() },
+    errorMessage: null
+  };
+}
+
+// src/interactive/startup-diagnostics.ts
+init_esm_shims();
+import { appendFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+function recordStartupDiagnostic(event) {
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  const directory = join(clioStateDir(), "startup");
+  void mkdir(directory, { recursive: true, mode: 448 }).then(
+    () => appendFile(join(directory, `${at.slice(0, 10)}.jsonl`), `${JSON.stringify({ ...event, at, pid: process.pid })}
+`, {
+      mode: 384
+    })
+  ).catch(() => {
+  });
+}
+
+export {
+  prewarmPromptTokens,
+  runPrewarmRound,
+  recordStartupDiagnostic
+};
+//# sourceMappingURL=chunk-BFOSV5EZ.js.map

package/dist/chunk-BGOIM7NB.js

@@ -0,0 +1,103 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  printError
+} from "./chunk-NBXFPI7U.js";
+import {
+  resolvePackageRoot
+} from "./chunk-ZPST2KQO.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/cli/gui.ts
+init_esm_shims();
+import { existsSync, lstatSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+var HELP = `Clio Coder graphical application
+
+Usage:
+  clio-coder gui [--open] [--port <0-65535>]
+  clio-coder gui background install [--open] [--port <1-65535>]
+  clio-coder gui background status|start|open|stop|uninstall
+  clio-coder gui launcher install|status|uninstall
+
+The foreground server prints a private launch link. --open opens your default
+browser. Press Ctrl+C to stop. --no-open explicitly disables browser opening.
+Optional --idle-exit <milliseconds> stops an idle foreground server.
+Use --path </app/path> to open a particular page. --reuse-background uses this
+installation's background app when configured, or starts a foreground server.
+
+On Linux with a systemd user session, background install keeps the app available
+at login. Open its launch link once, then install it from your browser. Background
+stop stops it now; background uninstall also removes its login and desktop entries.
+Other platforms can run the foreground app. Your CLI, terminal interface,
+headless runs, and graphical app use the same Clio runtime and configuration.
+`;
+async function runGuiCommand(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  try {
+    const root = resolvePackageRoot();
+    process.env.CLIO_CODER_PACKAGE_ROOT = root;
+    const entry = join(root, "dist/gui/server.js");
+    if (!existsSync(entry)) {
+      printError("The graphical application has not been built here. Run `pnpm run build` in this checkout.");
+      return 2;
+    }
+    const server = await import(pathToFileURL(entry).href);
+    await server.main(args);
+    return 0;
+  } catch (error) {
+    printError(error instanceof Error ? error.message : "Could not start the graphical application.");
+    return 1;
+  }
+}
+var GUI_UNINSTALL_ADVICE = {
+  lead: "To remove them, run from a build that includes the graphical application:",
+  command: "clio-coder gui background uninstall && clio-coder gui launcher uninstall"
+};
+async function prepareGuiUninstall(options) {
+  const paths = [
+    { label: "Graphical background service", path: join(options.stateDir, "gui/background") },
+    { label: "Desktop launcher", path: join(options.desktopPrefix, "applications/io.iowarp.ClioCoder.desktop") },
+    {
+      label: "Desktop launcher ownership record",
+      path: join(options.desktopPrefix, "applications/io.iowarp.ClioCoder.desktop.owner.json")
+    }
+  ];
+  const present = paths.filter(({ path }) => {
+    try {
+      lstatSync(path);
+      return true;
+    } catch (error) {
+      if (["ENOENT", "ENOTDIR"].includes(error.code ?? "")) return false;
+      throw error;
+    }
+  });
+  if (!present.length)
+    return {
+      items: [],
+      unmanaged: [],
+      remove: async () => {
+        if ((await prepareGuiUninstall(options)).items.length)
+          throw new Error("A web installation appeared during confirmation; run uninstall again.");
+      }
+    };
+  const packageRoot = options.packageRoot ?? resolvePackageRoot();
+  const entry = join(packageRoot, "dist/gui/server.js");
+  if (!existsSync(entry)) return { items: [], unmanaged: present, remove: async () => {
+  } };
+  const server = await import(pathToFileURL(entry).href);
+  const plan = await server.prepareGuiUninstall({ ...options, packageRoot });
+  return { ...plan, unmanaged: [] };
+}
+
+export {
+  runGuiCommand,
+  GUI_UNINSTALL_ADVICE,
+  prepareGuiUninstall
+};
+//# sourceMappingURL=chunk-BGOIM7NB.js.map