@iowarp/clio-coder 0.3.0

package/dist/run-3VSPP24F.js

@@ -0,0 +1,735 @@
+import {
+  flushRawStdout,
+  projectDispatchJsonEvent,
+  readFileArgsAsync,
+  restoreStdout,
+  runClioCommand,
+  setupSteerChannel,
+  takeOverStdout
+} from "./chunk-PS4PFJQP.js";
+import "./chunk-AMFR5YA3.js";
+import "./chunk-O4EJEDHO.js";
+import "./chunk-4UQA7NCT.js";
+import {
+  SchedulingDomainModule,
+  createPromptsDomainModule
+} from "./chunk-3DANZDGR.js";
+import {
+  AgentsDomainModule,
+  SafetyDomainModule
+} from "./chunk-JPOWPFCU.js";
+import {
+  LifecycleDomainModule
+} from "./chunk-NI4DEJMC.js";
+import {
+  ensureClioState
+} from "./chunk-7RBKDI66.js";
+import {
+  ConfigDomainModule,
+  loadDomains
+} from "./chunk-527KG6XR.js";
+import "./chunk-UU3R62TT.js";
+import "./chunk-6CWDTGUC.js";
+import "./chunk-BYEU76JP.js";
+import "./chunk-HMYNFFY4.js";
+import {
+  createContextDomainModule
+} from "./chunk-UWIJNAOB.js";
+import "./chunk-X3BR7HWV.js";
+import {
+  buildMemoryPromptSection,
+  canonicalMemoryRepositoryIdentity,
+  loadMemoryRecordsSync
+} from "./chunk-VOO7NYPP.js";
+import {
+  MiddlewareDomainModule,
+  ObservabilityDomainModule,
+  SessionDomainModule,
+  assistantTextFromEvent,
+  createDispatchDomainModule,
+  isToolProfileName
+} from "./chunk-GNGDQYDU.js";
+import {
+  ResourcesDomainModule
+} from "./chunk-2J63S4SF.js";
+import "./chunk-RQDWMVRB.js";
+import {
+  agentRoleFactsResolver,
+  requestExecutionRole
+} from "./chunk-7BHLZB3A.js";
+import "./chunk-TPOCL34A.js";
+import "./chunk-E3NYWENM.js";
+import {
+  AUTONOMY_LEVELS
+} from "./chunk-XV4ZJ6ZM.js";
+import {
+  loadSkills
+} from "./chunk-26BZQOAD.js";
+import "./chunk-WD6AJM35.js";
+import "./chunk-QV47YRF4.js";
+import "./chunk-CLJ5HLUD.js";
+import "./chunk-BBUH4VAA.js";
+import "./chunk-GOTUR54M.js";
+import "./chunk-KBR4MZZR.js";
+import "./chunk-XNISANGE.js";
+import "./chunk-KKKPTZLM.js";
+import "./chunk-ME6DNWIU.js";
+import "./chunk-262G75JS.js";
+import "./chunk-TFSSEXL6.js";
+import "./chunk-PIDUD6M2.js";
+import {
+  globalFlagPositionHint
+} from "./chunk-67MTHP2E.js";
+import {
+  ProvidersDomainModule,
+  withRunOverrides
+} from "./chunk-TKHQ4DGZ.js";
+import "./chunk-D5YD55AR.js";
+import {
+  readSettings
+} from "./chunk-JWHCJDCI.js";
+import {
+  THINKING_LEVELS
+} from "./chunk-UHTSULZS.js";
+import "./chunk-5LDRNKX2.js";
+import "./chunk-UGYAX5YI.js";
+import "./chunk-5N2FG33Q.js";
+import "./chunk-VPAWTYLY.js";
+import {
+  clioDataDir
+} from "./chunk-X3NE4WVW.js";
+import "./chunk-DXQNI4PC.js";
+
+// src/cli/args.ts
+var VALID_THINKING = THINKING_LEVELS;
+function parseRunCliArgs(argv) {
+  const parsed = {
+    help: false,
+    json: false,
+    jsonEvents: "full",
+    required: [],
+    noSkills: false,
+    continueSession: false,
+    skillPaths: [],
+    fileArgs: [],
+    messages: [],
+    diagnostics: []
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    const need = (flag) => {
+      const value = argv[i + 1];
+      if (value === void 0 || value.startsWith("-") && !isNumericLiteral(value)) {
+        parsed.diagnostics.push({ type: "error", message: `${flag} requires a value` });
+        return null;
+      }
+      i += 1;
+      return value;
+    };
+    if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+      continue;
+    }
+    if (arg === "--json") {
+      parsed.json = true;
+      continue;
+    }
+    if (arg === "--json-events") {
+      const value = need(arg);
+      if (value !== null) {
+        parsed.json = true;
+        if (value === "full" || value === "terminal") parsed.jsonEvents = value;
+        else parsed.diagnostics.push({ type: "error", message: "--json-events must be one of: full|terminal" });
+      }
+      continue;
+    }
+    if (arg === "--target") {
+      const value = need(arg);
+      if (value !== null) parsed.target = value;
+      continue;
+    }
+    if (arg === "--model") {
+      const value = need(arg);
+      if (value !== null) parsed.model = value;
+      continue;
+    }
+    if (arg === "--thinking") {
+      const value = need(arg);
+      if (value !== null) {
+        if (VALID_THINKING.includes(value)) parsed.thinking = value;
+        else
+          parsed.diagnostics.push({
+            type: "error",
+            message: "--thinking must be one of: off|minimal|low|medium|high|xhigh|max"
+          });
+      }
+      continue;
+    }
+    if (arg === "--autonomy") {
+      const value = need(arg);
+      if (value !== null) {
+        if (AUTONOMY_LEVELS.includes(value)) parsed.autonomy = value;
+        else
+          parsed.diagnostics.push({
+            type: "error",
+            message: "--autonomy must be one of: read-only|suggest|auto-edit|full-auto"
+          });
+      }
+      continue;
+    }
+    if (arg === "--temperature") {
+      const value = need(arg);
+      if (value !== null) setNumberOption(parsed, "temperature", value, { min: 0 });
+      continue;
+    }
+    if (arg === "--top-p") {
+      const value = need(arg);
+      if (value !== null) setNumberOption(parsed, "topP", value, { min: 0, max: 1 });
+      continue;
+    }
+    if (arg === "--top-k") {
+      const value = need(arg);
+      if (value !== null) setNumberOption(parsed, "topK", value, { min: 0, integer: true });
+      continue;
+    }
+    if (arg === "--min-p") {
+      const value = need(arg);
+      if (value !== null) setNumberOption(parsed, "minP", value, { min: 0, max: 1 });
+      continue;
+    }
+    if (arg === "--presence-penalty") {
+      const value = need(arg);
+      if (value !== null) setNumberOption(parsed, "presencePenalty", value);
+      continue;
+    }
+    if (arg === "--frequency-penalty") {
+      const value = need(arg);
+      if (value !== null) setNumberOption(parsed, "frequencyPenalty", value);
+      continue;
+    }
+    if (arg === "--repeat-penalty") {
+      const value = need(arg);
+      if (value !== null) setNumberOption(parsed, "repeatPenalty", value);
+      continue;
+    }
+    if (arg === "--agent") {
+      const value = need(arg);
+      if (value !== null) parsed.agentId = value;
+      continue;
+    }
+    if (arg === "--agent-profile" || arg === "--worker-profile" || arg === "--worker") {
+      const value = need(arg);
+      if (value !== null) parsed.agentProfile = value;
+      continue;
+    }
+    if (arg === "--agent-runtime" || arg === "--worker-runtime" || arg === "--runtime") {
+      const value = need(arg);
+      if (value !== null) parsed.agentRuntime = value;
+      continue;
+    }
+    if (arg === "--tool-profile") {
+      const value = need(arg);
+      if (value !== null) parsed.toolProfile = value;
+      continue;
+    }
+    if (arg === "--require") {
+      const value = need(arg);
+      if (value !== null) parsed.required.push(value);
+      continue;
+    }
+    if (arg === "--no-skills") {
+      parsed.noSkills = true;
+      continue;
+    }
+    if (arg === "--skill") {
+      const value = need(arg);
+      if (value !== null) parsed.skillPaths.push(value);
+      continue;
+    }
+    if (arg === "--max-context-tokens") {
+      const value = need(arg);
+      if (value !== null) {
+        const n = Number(value);
+        if (Number.isInteger(n) && n > 0) {
+          parsed.maxContextTokens = n;
+        } else {
+          parsed.diagnostics.push({ type: "error", message: "--max-context-tokens must be a positive integer" });
+        }
+      }
+      continue;
+    }
+    if (arg === "--kv-cache-mode") {
+      const value = need(arg);
+      if (value !== null) {
+        parsed.kvCacheMode = value;
+      }
+      continue;
+    }
+    if (arg === "--session") {
+      const value = need(arg);
+      if (value !== null) {
+        parsed.sessionId = value;
+      }
+      continue;
+    }
+    if (arg === "--continue") {
+      parsed.continueSession = true;
+      continue;
+    }
+    if (arg === "--steer-channel") {
+      const value = need(arg);
+      if (value !== null) {
+        parsed.steerChannel = value;
+      }
+      continue;
+    }
+    if (arg?.startsWith("-")) {
+      parsed.diagnostics.push({
+        type: "error",
+        message: globalFlagPositionHint(arg, "run") ?? `unknown clio-coder run option: ${arg}`
+      });
+      continue;
+    }
+    if (arg !== void 0) {
+      if (arg.startsWith("@") && arg.length > 1) parsed.fileArgs.push(arg.slice(1));
+      else parsed.messages.push(arg);
+    }
+  }
+  return parsed;
+}
+function setNumberOption(parsed, key, raw, limits = {}) {
+  const value = Number(raw);
+  if (!Number.isFinite(value)) {
+    parsed.diagnostics.push({ type: "error", message: `--${kebab(key)} must be a number` });
+    return;
+  }
+  if (limits.min !== void 0 && value < limits.min) {
+    parsed.diagnostics.push({ type: "error", message: `--${kebab(key)} must be >= ${limits.min}` });
+    return;
+  }
+  if (limits.max !== void 0 && value > limits.max) {
+    parsed.diagnostics.push({ type: "error", message: `--${kebab(key)} must be <= ${limits.max}` });
+    return;
+  }
+  const normalized = limits.integer === true ? Math.floor(value) : value;
+  parsed.sampling = { ...parsed.sampling ?? {}, [key]: normalized };
+}
+function kebab(value) {
+  return value.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}
+function isNumericLiteral(value) {
+  return value.startsWith("-") && !value.startsWith("--") && Number.isFinite(Number(value));
+}
+
+// src/cli/initial-message.ts
+async function readPipedStdin() {
+  if (process.stdin.isTTY) return void 0;
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      resolve(data.length > 0 ? data : void 0);
+    });
+    process.stdin.resume();
+  });
+}
+function shouldReadPipedStdin(messages) {
+  return messages.length === 0;
+}
+function buildInitialMessage(input) {
+  const parts = [];
+  if (input.stdinContent !== void 0) parts.push(input.stdinContent);
+  if (input.fileText) parts.push(input.fileText);
+  const [first, ...rest] = input.messages;
+  if (first !== void 0) parts.push(first);
+  const result = { remainingMessages: rest };
+  if (parts.length > 0) result.initialMessage = parts.join("");
+  if (input.fileImages && input.fileImages.length > 0) result.initialImages = [...input.fileImages];
+  return result;
+}
+
+// src/cli/run.ts
+var USAGE = 'usage: clio-coder run [--target <id>] [--model <wireId>] [--thinking <level>] [--autonomy <level>] [--json] [--json-events full|terminal] [--session <id>|--continue] [--agent <recipe-id>] "<task>"\n';
+var HELP = `clio-coder run [flags] "<task>"
+
+Run one headless main-agent turn. Fleet dispatch is explicit with --agent.
+
+Flags:
+  --target <id>             one-run main-agent or dispatch target override
+  --model <wireId>          one-run model override
+  --thinking <level>        one-run thinking level: off|minimal|low|medium|high|xhigh|max
+  --autonomy <level>        one-run autonomy: read-only|suggest|auto-edit|full-auto
+  --temperature <N>         one-run sampler override for supported local/OpenAI-compatible runtimes
+  --top-p <N>               one-run nucleus sampling override (0..1)
+  --top-k <N>               one-run top-k override
+  --min-p <N>               one-run min-p override (0..1)
+  --presence-penalty <N>    one-run presence penalty override
+  --frequency-penalty <N>   one-run frequency penalty override
+  --repeat-penalty <N>      one-run repeat penalty override
+  --max-context-tokens <N>  one-run context-window override for supported local runtimes
+  --kv-cache-mode <mode>    one-run KV-cache mode override: f16|f32|none|false|q8_0|q4_0|q4_1|iq4_nl|q5_0|q5_1
+  --json                    stream JSONL events for the main-agent path; dispatch streams events and receipt JSON
+  --json-events <mode>      main-agent JSON stream mode: full|terminal; implies --json
+  --steer-channel <path>    read live steering lines from a FIFO or appended regular file
+  --session <id>            append this turn to an existing session
+  --continue                append this turn to the most recent session for this cwd
+  --agent <recipe-id>       dispatch a fleet agent instead of the main agent
+  --agent-profile <name>    named fleet profile for dispatch
+  --agent-runtime <id>      pick the first fleet profile whose target uses this runtime
+  --tool-profile <name>     restrict dispatched-agent tools: minimal-local|science-local|full-agent
+  --require <capability>    capability the dispatch target must advertise (repeatable)
+  --skill <path>            load one explicit skill for this run, repeatable
+  --no-skills               disable skill discovery while still honoring --skill
+
+A headless turn starts a fresh session unless --session or --continue names one
+to append to. A named session that cannot be resumed fails the run: an answer
+written without the history the caller asked for is worse than no answer. The
+session id is reported on stderr, and as the "session" event under --json.
+
+There is no operator in a headless run: permission asks are denied, and the
+ask_user interview tool is not registered. Skills that interview fall back to
+their stated defaults; supply decisions in the task prompt instead.
+
+A turn that ends by writing an artifact (plan/review/report) has no assistant
+message after it, because writing the artifact is the answer. Text mode prints
+that tool's result line, naming what was written and where; --json carries the
+artifact content itself in the event stream.
+`;
+function hasDispatchOnlyOptions(parsed) {
+  return parsed.agentProfile !== void 0 || parsed.agentRuntime !== void 0 || parsed.toolProfile !== void 0 || parsed.required.length > 0;
+}
+function explicitTargetMissing(targetId) {
+  try {
+    return !readSettings().targets.some((target) => target.id === targetId);
+  } catch {
+    return false;
+  }
+}
+async function assemblePrompt(parsed) {
+  const messages = parsed.messages.length > 0 ? [parsed.messages.join(" ")] : [];
+  const stdinContent = shouldReadPipedStdin(messages) ? await readPipedStdin() : void 0;
+  const fileRefs = await readFileArgsAsync(parsed.fileArgs, { cwd: process.cwd(), missing: "error" });
+  for (const diagnostic of fileRefs.diagnostics) {
+    process.stderr.write(`error: ${diagnostic.message}
+`);
+  }
+  if (fileRefs.diagnostics.some((diagnostic) => diagnostic.type === "error")) return null;
+  const initial = buildInitialMessage({
+    messages,
+    ...stdinContent !== void 0 ? { stdinContent } : {},
+    ...fileRefs.text.length > 0 ? { fileText: fileRefs.text } : {},
+    ...fileRefs.images.length > 0 ? { fileImages: fileRefs.images } : {}
+  });
+  if (!initial.initialMessage || initial.initialMessage.trim().length === 0) {
+    process.stderr.write("clio-coder run: empty task\n");
+    process.stderr.write(USAGE);
+    return null;
+  }
+  return {
+    prompt: initial.initialMessage,
+    ...initial.initialImages && initial.initialImages.length > 0 ? { images: initial.initialImages } : {},
+    ...fileRefs.referencedPaths.length > 0 ? { workingContextPaths: fileRefs.referencedPaths } : {}
+  };
+}
+function explicitSkillPathErrors(skillPaths) {
+  const errors = [];
+  for (const skillPath of skillPaths) {
+    const list = loadSkills({ disableDiscovery: true, explicitSkillPaths: [skillPath] });
+    if (list.items.length > 0) continue;
+    const detail = list.diagnostics.map((diagnostic) => diagnostic.message).join("; ");
+    errors.push(detail.length > 0 ? detail : `explicit skill path loaded no skills: ${skillPath}`);
+  }
+  return errors;
+}
+async function runClioRun(args, options = {}) {
+  const parsed = parseRunCliArgs(args);
+  return withRunOverrides(
+    {
+      ...parsed.maxContextTokens !== void 0 ? { maxContextTokens: parsed.maxContextTokens } : {},
+      ...parsed.kvCacheMode !== void 0 ? { kvCacheMode: parsed.kvCacheMode } : {}
+    },
+    async () => {
+      if (parsed.help) {
+        process.stdout.write(HELP);
+        return 0;
+      }
+      for (const diagnostic of parsed.diagnostics) {
+        process.stderr.write(`clio-coder run: ${diagnostic.message}
+`);
+      }
+      if (parsed.diagnostics.some((diagnostic) => diagnostic.type === "error")) {
+        process.stderr.write(USAGE);
+        return 2;
+      }
+      if (parsed.agentId === void 0 && hasDispatchOnlyOptions(parsed)) {
+        process.stderr.write("clio-coder run: fleet dispatch flags require --agent <recipe-id>\n");
+        process.stderr.write(USAGE);
+        return 2;
+      }
+      if (parsed.sessionId !== void 0 && parsed.continueSession) {
+        process.stderr.write("clio-coder run: --session and --continue name different sessions; pass one\n");
+        process.stderr.write(USAGE);
+        return 2;
+      }
+      if ((parsed.sessionId !== void 0 || parsed.continueSession) && parsed.agentId !== void 0) {
+        process.stderr.write("clio-coder run: --session and --continue apply to the main agent, not --agent dispatch\n");
+        process.stderr.write(USAGE);
+        return 2;
+      }
+      const noSkills = options.noSkills === true || parsed.noSkills === true;
+      const skillPaths = Array.from(/* @__PURE__ */ new Set([...options.skillPaths ?? [], ...parsed.skillPaths]));
+      const skillPathErrors = explicitSkillPathErrors(skillPaths);
+      if (skillPathErrors.length > 0) {
+        for (const message of skillPathErrors) {
+          process.stderr.write(`clio-coder run: --skill ${message}
+`);
+        }
+        return 2;
+      }
+      const assembled = await assemblePrompt(parsed);
+      if (!assembled) return 2;
+      if (parsed.agentId === void 0) {
+        if (parsed.target !== void 0 && explicitTargetMissing(parsed.target)) {
+          process.stderr.write(`clio-coder run: target '${parsed.target}' not found in settings.targets
+`);
+          return 2;
+        }
+        takeOverStdout();
+        try {
+          const code = await runClioCommand({
+            ...options.apiKey === void 0 ? {} : { apiKey: options.apiKey },
+            ...options.noContextFiles ? { noContextFiles: true } : {},
+            ...noSkills ? { noSkills: true } : {},
+            ...skillPaths.length > 0 ? { skillPaths } : {},
+            headless: {
+              prompt: assembled.prompt,
+              mode: parsed.json ? "json" : "text",
+              jsonEvents: parsed.jsonEvents,
+              ...noSkills ? { noSkills: true } : {},
+              ...skillPaths.length > 0 ? { skillPaths } : {},
+              ...assembled.images && assembled.images.length > 0 ? { images: assembled.images } : {},
+              ...assembled.workingContextPaths && assembled.workingContextPaths.length > 0 ? { workingContextPaths: assembled.workingContextPaths } : {},
+              ...parsed.target !== void 0 ? { target: parsed.target } : {},
+              ...parsed.model !== void 0 ? { model: parsed.model } : {},
+              ...parsed.thinking !== void 0 ? { thinking: parsed.thinking } : {},
+              ...parsed.autonomy !== void 0 ? { autonomy: parsed.autonomy } : {},
+              ...parsed.sampling !== void 0 ? { sampling: parsed.sampling } : {},
+              ...parsed.steerChannel !== void 0 ? { steerChannel: parsed.steerChannel } : {},
+              ...parsed.sessionId !== void 0 ? { resumeSession: { kind: "id", id: parsed.sessionId } } : parsed.continueSession ? { resumeSession: { kind: "latest" } } : {}
+            }
+          });
+          await flushRawStdout();
+          return code;
+        } finally {
+          restoreStdout();
+        }
+      }
+      return await runDispatch(parsed, assembled.prompt, {
+        ...options,
+        noSkills,
+        skillPaths
+      });
+    }
+  );
+}
+async function runDispatch(parsed, task, options) {
+  if (parsed.toolProfile !== void 0 && !isToolProfileName(parsed.toolProfile)) {
+    process.stderr.write("clio-coder run: --tool-profile must be one of: minimal-local|science-local|full-agent\n");
+    process.stderr.write(USAGE);
+    return 2;
+  }
+  if (parsed.target && parsed.agentProfile) {
+    process.stderr.write(
+      `clio-coder run: --target ${parsed.target} takes precedence; --agent-profile ${parsed.agentProfile} will be ignored
+`
+    );
+  }
+  if (parsed.target && parsed.agentRuntime) {
+    process.stderr.write(
+      `clio-coder run: --target ${parsed.target} takes precedence; --agent-runtime ${parsed.agentRuntime} will be ignored
+`
+    );
+  }
+  ensureClioState();
+  let effectiveSettings;
+  const loaded = await loadDomains([
+    ConfigDomainModule,
+    ResourcesDomainModule,
+    createContextDomainModule({ noContextFiles: options.noContextFiles === true }),
+    ProvidersDomainModule,
+    SafetyDomainModule,
+    createPromptsDomainModule({ noContextFiles: options.noContextFiles === true }),
+    AgentsDomainModule,
+    MiddlewareDomainModule,
+    SessionDomainModule,
+    // Observability subscribes to the dispatch terminal events so a headless
+    // run auto-builds its forensic evidence bundle and sidecar index, the same
+    // as an interactive session. It depends only on providers + session, both
+    // loaded above.
+    ObservabilityDomainModule,
+    SchedulingDomainModule,
+    createDispatchDomainModule({
+      getSettings: () => effectiveSettings,
+      autonomyOverride: parsed.autonomy !== void 0
+    }),
+    LifecycleDomainModule
+  ]);
+  const config = loaded.getContract("config");
+  const baseSettings = config?.get() ?? readSettings();
+  effectiveSettings = parsed.autonomy === void 0 ? baseSettings : { ...structuredClone(baseSettings), autonomy: parsed.autonomy };
+  const dispatch = loaded.getContract("dispatch");
+  if (!dispatch) {
+    process.stderr.write("dispatch domain unavailable\n");
+    await loaded.stop();
+    return 1;
+  }
+  if (options.apiKey) {
+    const providers = loaded.getContract("providers");
+    if (!providers) {
+      process.stderr.write("clio-coder run: --api-key supplied but providers domain unavailable\n");
+      await loaded.stop();
+      return 1;
+    }
+    const settings = effectiveSettings;
+    const profileTargetId = parsed.agentProfile ? settings.workers?.profiles?.[parsed.agentProfile]?.target : void 0;
+    const runtimeByTarget = new Map(settings.targets.map((target2) => [target2.id, target2.runtime]));
+    const runtimeTargetId = parsed.agentRuntime ? [settings.workers?.default, ...Object.values(settings.workers?.profiles ?? {})].find(
+      (profile) => profile?.target && runtimeByTarget.get(profile.target) === parsed.agentRuntime
+    )?.target : void 0;
+    const targetId = parsed.target ?? profileTargetId ?? runtimeTargetId ?? settings.workers?.default?.target ?? settings.orchestrator?.target;
+    const target = targetId ? providers.getTarget(targetId) : null;
+    const runtime = target ? providers.getRuntime(target.runtime) : null;
+    if (!target || !runtime) {
+      process.stderr.write("clio-coder run: --api-key supplied but no target resolved; pass --target <id>\n");
+      await loaded.stop();
+      return 2;
+    }
+    providers.auth.setRuntimeOverrideForTarget(target, runtime, options.apiKey);
+  }
+  const noSkills = options.noSkills === true || parsed.noSkills === true;
+  const skillPaths = Array.from(/* @__PURE__ */ new Set([...options.skillPaths ?? [], ...parsed.skillPaths]));
+  const runAgents = loaded.getContract("agents");
+  const dispatchReq = {
+    agentId: parsed.agentId,
+    executionRole: requestExecutionRole({
+      agentId: parsed.agentId,
+      ...runAgents ? { resolveFacts: agentRoleFactsResolver((id) => runAgents.getSpec(id)) } : {}
+    }),
+    task,
+    requestOrigin: "user"
+  };
+  if (parsed.agentProfile) dispatchReq.workerProfile = parsed.agentProfile;
+  if (parsed.agentRuntime) dispatchReq.workerRuntime = parsed.agentRuntime;
+  if (parsed.target) dispatchReq.target = parsed.target;
+  if (parsed.model) dispatchReq.model = parsed.model;
+  if (parsed.thinking) dispatchReq.thinkingLevel = parsed.thinking;
+  if (parsed.toolProfile) dispatchReq.toolProfile = parsed.toolProfile;
+  if (parsed.required.length > 0) dispatchReq.requiredCapabilities = parsed.required;
+  if (noSkills) dispatchReq.noSkills = true;
+  if (skillPaths.length > 0) dispatchReq.skillPaths = skillPaths;
+  try {
+    const settings = effectiveSettings;
+    if (settings.skills?.trustProjectCompatRoots) {
+      dispatchReq.trustProjectCompatRoots = true;
+    }
+  } catch {
+  }
+  let memorySection = "";
+  try {
+    const records = loadMemoryRecordsSync(clioDataDir());
+    memorySection = buildMemoryPromptSection(records, {
+      activeRepository: canonicalMemoryRepositoryIdentity(process.cwd())
+    }).section;
+  } catch (err) {
+    process.stderr.write(
+      `clio-coder run: memory load failed: ${err instanceof Error ? err.message : String(err)}; continuing without memory
+`
+    );
+  }
+  if (memorySection.length > 0) dispatchReq.memorySection = memorySection;
+  let cleanupSteer;
+  try {
+    const handle = await dispatch.dispatch(dispatchReq);
+    if (parsed.steerChannel) {
+      cleanupSteer = setupSteerChannel(parsed.steerChannel, (line) => {
+        try {
+          dispatch.steer(handle.runId, line);
+        } catch {
+        }
+      });
+    }
+    const onSignal = () => dispatch.abort(handle.runId);
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+    let accumulatedText = "";
+    let lastAssistantText = "";
+    for await (const event of handle.events) {
+      if (parsed.json) {
+        process.stdout.write(`${JSON.stringify(projectDispatchJsonEvent(event))}
+`);
+        continue;
+      }
+      const e = event;
+      if (e.type === "attempt_start") {
+        accumulatedText = "";
+        lastAssistantText = "";
+        continue;
+      }
+      if (e.type === "text_delta" && typeof e.text === "string") {
+        accumulatedText += e.text;
+      }
+      const assistantText = assistantTextFromEvent(event);
+      if (assistantText.length > 0) lastAssistantText = assistantText;
+    }
+    const receipt = await handle.finalPromise;
+    if (cleanupSteer) {
+      cleanupSteer();
+      cleanupSteer = void 0;
+    }
+    if (parsed.json) {
+      process.stdout.write(`
+${JSON.stringify(receipt, null, 2)}
+`);
+    } else {
+      const answer = lastAssistantText.length > 0 ? lastAssistantText : accumulatedText.trim();
+      if (answer.length > 0) process.stdout.write(`${answer}
+`);
+      process.stdout.write(`${formatReceipt(receipt)}
+`);
+    }
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+    await dispatch.drain();
+    await loaded.stop();
+    return mapExitCode(receipt);
+  } catch (err) {
+    if (cleanupSteer) {
+      cleanupSteer();
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`clio-coder run failed: ${msg}
+`);
+    await loaded.stop();
+    if (/target '.+' not found/.test(msg)) return 2;
+    if (msg.includes("unknown agent recipe") || msg.includes("admission") || msg.includes("capability") || msg.includes("budget"))
+      return 2;
+    return 1;
+  }
+}
+function formatReceipt(r) {
+  const reasoning = typeof r.reasoningTokenCount === "number" && r.reasoningTokenCount > 0 ? ` reasoning=${r.reasoningTokenCount}` : "";
+  const failure = r.failureMessage ? ` error=${r.failureMessage}` : "";
+  return `receipt: ${r.runId} agent=${r.agentId} exit=${r.exitCode} target=${r.targetId} model=${r.wireModelId} tokens=${r.tokenCount}${reasoning}${failure} start=${r.startedAt} end=${r.endedAt}`;
+}
+function mapExitCode(r) {
+  if (r.exitCode === 0) return 0;
+  return r.exitCode === 2 ? 2 : 1;
+}
+export {
+  explicitSkillPathErrors,
+  runClioRun
+};
+//# sourceMappingURL=run-3VSPP24F.js.map