@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/run-H64MEVTA.js

@@ -0,0 +1,1067 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  runClioCommand
+} from "./chunk-X4CEFOSG.js";
+import {
+  projectDispatchJsonEvent,
+  setupSteerChannel
+} from "./chunk-CBAQPTDU.js";
+import {
+  SchedulingDomainModule,
+  createPromptsDomainModule
+} from "./chunk-3JLTRPN7.js";
+import {
+  LifecycleDomainModule
+} from "./chunk-4VDHLCF5.js";
+import "./chunk-HOYZUKG7.js";
+import "./chunk-QHSBROEW.js";
+import {
+  flushRawStdout,
+  restoreStdout,
+  takeOverStdout
+} from "./chunk-7WLRF2U5.js";
+import "./chunk-NASYVWDB.js";
+import "./chunk-IN7DGBVS.js";
+import {
+  ensureClioState
+} from "./chunk-NOCSM22Y.js";
+import "./chunk-KW5HXKLJ.js";
+import "./chunk-URCXX7WJ.js";
+import "./chunk-U26XXPJS.js";
+import "./chunk-ZR5YA6ZF.js";
+import "./chunk-T2MDZES3.js";
+import "./chunk-4A6YRGV4.js";
+import {
+  AgentsDomainModule
+} from "./chunk-UCINIRHW.js";
+import {
+  ObservabilityDomainModule
+} from "./chunk-HQVN7G4F.js";
+import "./chunk-V35KZDUZ.js";
+import "./chunk-HOEDA42N.js";
+import {
+  ResourcesDomainModule
+} from "./chunk-4WOOTKFD.js";
+import "./chunk-Y3JU5RPK.js";
+import "./chunk-6OWUM2NC.js";
+import {
+  ConfigDomainModule
+} from "./chunk-JPXLJSGR.js";
+import "./chunk-3UW3KU4A.js";
+import "./chunk-GN7QBEEI.js";
+import {
+  assistantTextFromEvent,
+  buildMemoryPromptSection,
+  canonicalMemoryRepositoryIdentity,
+  createContextDomainModule,
+  createDispatchDomainModule,
+  loadMemoryRecordsSync,
+  receiptGatewayRoutingLabel,
+  receiptResponseModelIdObservationLabel
+} from "./chunk-LTWH2ACR.js";
+import "./chunk-PECBKCDK.js";
+import "./chunk-OV62D6KO.js";
+import "./chunk-I4ELN5BX.js";
+import "./chunk-DXSETN72.js";
+import "./chunk-NFSK2VNU.js";
+import "./chunk-OZ76TLGU.js";
+import {
+  SessionDomainModule
+} from "./chunk-EOJPDNUP.js";
+import "./chunk-BOBCCDJ6.js";
+import "./chunk-E6IPKW2E.js";
+import {
+  SafetyDomainModule
+} from "./chunk-XMDBTYCH.js";
+import {
+  configureRunEventJournal
+} from "./chunk-UQIVHSE4.js";
+import "./chunk-BYFHHCFV.js";
+import "./chunk-TKDRT2DF.js";
+import "./chunk-LQTKDAUO.js";
+import "./chunk-ZU4JPCPR.js";
+import "./chunk-U5QU5ZOD.js";
+import "./chunk-DNHVRBH4.js";
+import "./chunk-O5F25NIE.js";
+import "./chunk-U6YTUVOX.js";
+import "./chunk-SD7SHNDW.js";
+import "./chunk-7RET77VB.js";
+import "./chunk-YQ3GFEUY.js";
+import "./chunk-WTQGRBHV.js";
+import "./chunk-GLIQT7SU.js";
+import "./chunk-BHJMMCXS.js";
+import "./chunk-FXFVDPWY.js";
+import {
+  globalFlagPositionHint
+} from "./chunk-NBXFPI7U.js";
+import "./chunk-SQZHXUB3.js";
+import "./chunk-SUTLW6ND.js";
+import "./chunk-G5R53COU.js";
+import "./chunk-GM4TY6VN.js";
+import "./chunk-XISLDHEL.js";
+import "./chunk-RNDCROSG.js";
+import "./chunk-5KQEUIWM.js";
+import "./chunk-5JQR5B4D.js";
+import "./chunk-ZARZ4POR.js";
+import "./chunk-UX2L5CUD.js";
+import {
+  loadSkills
+} from "./chunk-LAR7DX5E.js";
+import "./chunk-DNCE23JJ.js";
+import "./chunk-CDQ2UC6W.js";
+import "./chunk-5LP5FNNR.js";
+import "./chunk-NVPXXW2H.js";
+import {
+  readStrictLayeredSettings
+} from "./chunk-ZNUZ3EXD.js";
+import "./chunk-R7FGRZNF.js";
+import "./chunk-DOUISWEE.js";
+import "./chunk-VKHLUZNO.js";
+import {
+  MiddlewareDomainModule
+} from "./chunk-OQ2EOAHA.js";
+import "./chunk-NDPF2N2L.js";
+import "./chunk-7QXCO3AF.js";
+import "./chunk-T33IYTZM.js";
+import "./chunk-OH3YYA3B.js";
+import "./chunk-VESL6DQY.js";
+import "./chunk-FD3IAHQM.js";
+import "./chunk-XNIZBOFV.js";
+import {
+  isToolProfileName
+} from "./chunk-XZWSP67B.js";
+import {
+  agentRoleFactsResolver,
+  requestExecutionRole
+} from "./chunk-BRCOSE7O.js";
+import "./chunk-55RMDDFM.js";
+import "./chunk-L4N3DWNW.js";
+import "./chunk-TDGYTWM6.js";
+import "./chunk-CTFPFW3H.js";
+import "./chunk-DE2LU267.js";
+import "./chunk-YYLCPDCC.js";
+import "./chunk-EFSEIZE6.js";
+import "./chunk-KBUTSJSR.js";
+import {
+  readFileArgsAsync
+} from "./chunk-YBUECLAF.js";
+import "./chunk-CRHPCPZP.js";
+import "./chunk-FFYTC2KQ.js";
+import "./chunk-UJD5MPP6.js";
+import "./chunk-DZLR4UEH.js";
+import "./chunk-OPD7GL6F.js";
+import "./chunk-733ZBT5P.js";
+import "./chunk-GHXGMFQ5.js";
+import "./chunk-KECNXMDE.js";
+import "./chunk-WXA2CFJO.js";
+import "./chunk-6CTHLZFB.js";
+import "./chunk-2KUBKL63.js";
+import "./chunk-MYI32N4R.js";
+import "./chunk-X6FLVUM5.js";
+import {
+  ProvidersDomainModule,
+  withRunOverrides
+} from "./chunk-EYTLV3W3.js";
+import "./chunk-MCJKEGHO.js";
+import "./chunk-DVTBERFY.js";
+import "./chunk-6EJYVCTN.js";
+import "./chunk-W53XSRQE.js";
+import "./chunk-6W75D37F.js";
+import "./chunk-77DCC6JZ.js";
+import "./chunk-SYF7FVBL.js";
+import "./chunk-Z4GLJ6J4.js";
+import "./chunk-VNBICSS2.js";
+import "./chunk-2WVPJF3Z.js";
+import "./chunk-27YTM2CV.js";
+import "./chunk-L7G7K4I2.js";
+import "./chunk-ALJWT6O6.js";
+import "./chunk-4WV4PI66.js";
+import "./chunk-HMN2C6YL.js";
+import "./chunk-I4Y4WKZR.js";
+import {
+  AUTONOMY_LEVELS
+} from "./chunk-UZVYEF57.js";
+import "./chunk-O3VV6IVK.js";
+import "./chunk-EKV4UBCM.js";
+import "./chunk-UHW5V7HC.js";
+import "./chunk-LNOXCGN2.js";
+import "./chunk-BJH6WFIB.js";
+import "./chunk-5EQO5NWP.js";
+import "./chunk-VYRQHORQ.js";
+import "./chunk-P4GNZPXO.js";
+import "./chunk-R2P2U3ZS.js";
+import "./chunk-NTTS3O53.js";
+import "./chunk-C2CPOIH2.js";
+import "./chunk-MGLRTOCK.js";
+import "./chunk-M4KFUXS7.js";
+import "./chunk-V4XJWDHR.js";
+import {
+  readSettings
+} from "./chunk-56XP4FJU.js";
+import {
+  THINKING_LEVELS
+} from "./chunk-QZTTRSJE.js";
+import "./chunk-U2MSJ57E.js";
+import "./chunk-C27U2TYG.js";
+import "./chunk-B5GGDIHT.js";
+import "./chunk-O63U2I6I.js";
+import "./chunk-M2IPMWCN.js";
+import "./chunk-XS2QPZJE.js";
+import {
+  MAX_TIMER_DELAY_MS
+} from "./chunk-6EXUUOSN.js";
+import "./chunk-ZTNFYMIO.js";
+import "./chunk-53OXPRI6.js";
+import "./chunk-2EMLKSCX.js";
+import "./chunk-KMF54VH3.js";
+import "./chunk-DVJL77SO.js";
+import "./chunk-SER7RRAE.js";
+import "./chunk-GH5ZR6JP.js";
+import "./chunk-TK2BMCBZ.js";
+import {
+  clioDataDir
+} from "./chunk-CTTI7G3T.js";
+import "./chunk-QG6I2T5E.js";
+import "./chunk-CVDAFGPW.js";
+import "./chunk-KPRLAMP4.js";
+import "./chunk-W2RJEH6Q.js";
+import "./chunk-PPEZJWUG.js";
+import "./chunk-WDV62RKY.js";
+import "./chunk-ZZFWWYLX.js";
+import "./chunk-2VLYHHFT.js";
+import "./chunk-3JHUFKG7.js";
+import "./chunk-ZPST2KQO.js";
+import {
+  loadDomains
+} from "./chunk-L4APUGCT.js";
+import {
+  getTerminationCoordinator
+} from "./chunk-DCGHJQ2U.js";
+import "./chunk-JQCLXSFI.js";
+import "./chunk-PS6JAWJZ.js";
+import "./chunk-FD2I4KBR.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/cli/run.ts
+init_esm_shims();
+import { realpathSync } from "node:fs";
+import path from "node:path";
+
+// src/cli/args.ts
+init_esm_shims();
+var VALID_THINKING = THINKING_LEVELS;
+function parseRunCliArgs(argv) {
+  const parsed = {
+    help: false,
+    json: false,
+    jsonEvents: "full",
+    required: [],
+    noSkills: false,
+    continueSession: false,
+    failOnNoop: 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") {
+      const value = need(arg);
+      if (value !== null) parsed.agentProfile = value;
+      continue;
+    }
+    if (arg === "--agent-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 === "--turn-mode") {
+      const value = need(arg);
+      if (value === "answer" || value === "proposal" || value === "change")
+        parsed.constraints = { ...parsed.constraints, mode: value };
+      else if (value !== null)
+        parsed.diagnostics.push({ type: "error", message: "--turn-mode must be answer, proposal, or change" });
+      continue;
+    }
+    if (arg === "--no-delegate") {
+      parsed.constraints = { ...parsed.constraints, delegation: "forbidden" };
+      continue;
+    }
+    if (arg === "--allow-tools") {
+      const value = need(arg);
+      if (value !== null) {
+        const names = value === "none" ? [] : value.split(",").map((name) => name.trim());
+        if (names.some((name) => !/^[a-zA-Z0-9_.-]+$/.test(name)))
+          parsed.diagnostics.push({
+            type: "error",
+            message: "--allow-tools needs comma-separated capability names, or none"
+          });
+        else parsed.constraints = { ...parsed.constraints, allowedTools: [...new Set(names)] };
+      }
+      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 === "--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 === "--timeout") {
+      const value = need(arg);
+      if (value !== null) {
+        const seconds = Number(value);
+        if (Number.isFinite(seconds) && seconds > 0 && seconds * 1e3 <= MAX_TIMER_DELAY_MS) {
+          parsed.timeoutSeconds = seconds;
+        } else {
+          parsed.diagnostics.push({
+            type: "error",
+            message: `--timeout must be a positive number of seconds no greater than ${Math.floor(MAX_TIMER_DELAY_MS / 1e3)}`
+          });
+        }
+      }
+      continue;
+    }
+    if (arg === "--fail-on-noop") {
+      parsed.failOnNoop = true;
+      continue;
+    }
+    if (arg === "--cwd") {
+      const value = need(arg);
+      if (value !== null) parsed.cwd = 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
+init_esm_shims();
+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 [--cwd <dir>] [--target <id>] [--model <wireId>] [--thinking <level>] [--autonomy <level>] [--json] [--json-events full|terminal] [--session <id>|--continue] [--fail-on-noop] [--timeout <seconds>] [--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:
+  --cwd <dir>               run as if started in <dir>; applies to --agent too
+  --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
+  --turn-mode <mode>        main-agent workflow: answer|proposal|change; not an authorization grant
+  --allow-tools <names>     main-agent capability allowlist, comma-separated; none disables all tools
+  --no-delegate            forbid main-agent dispatch for this task and its continuations
+  --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>  cap this run's context budget without enlarging the server window
+  --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
+  --fail-on-noop            exit 1 when the main-agent run changed nothing (see below)
+  --timeout <seconds>       wall-clock limit for the whole main-agent run; exit 124 on expiry
+  --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
+
+--cwd enters <dir> before anything reads the working directory: settings
+layers, context files, skills, @file references, the session ledger, and every
+tool path. A run started with --cwd <dir> behaves as if it had been started in
+<dir>, so relative paths in other arguments resolve there too. A directory the
+process cannot enter is a usage error (exit 2) and no model is called.
+CLIO_CODER_HOME, CLIO_CODER_CONFIG_DIR, CLIO_CODER_DATA_DIR,
+CLIO_CODER_STATE_DIR, and CLIO_CODER_CACHE_DIR are not resolved before the
+chdir, so a relative value lands under <dir>. Pass absolute paths in them
+when using --cwd.
+
+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.
+
+Every main-agent receipt records blocked calls under safety.blockedAttempts and
+a noop flag. A run is a no-op when a block remains unresolved and no write
+succeeded, or when it ran tools and none succeeded; a run that called no tool
+is not. Only the main agent's own write-class calls count as writes: an
+artifact report, bash, and dispatch work do not. A later successful read or
+command can recover a block of the same action class. Native observation does
+not certify that a blocked execution or write requirement was fulfilled.
+Bookkeeping and reports cannot recover blocks. An unresolved blocked run with no successful write exits 1 with outcome
+"failed" and outcomeDetail "noop".
+A successful limitation call also fails, with outcomeDetail "limitation".
+--fail-on-noop additionally fails runs whose tools all failed without a block.
+The flag applies to the main agent only.
+
+--timeout <seconds> bounds the whole run, boot included. On expiry the run
+starts the same coordinated shutdown a SIGTERM does: the turn is aborted, a
+running bash tool's process group is signalled, and the receipt is sealed with
+outcome "timed_out" before the process exits 124, the code timeout(1) uses. An
+external SIGTERM still seals "canceled" with exit 143. A timeout during boot,
+before the turn starts, exits 124 with no receipt. Main agent only.
+
+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 enterRunCwd(value) {
+  const resolved = path.resolve(value);
+  try {
+    process.chdir(realpathSync(resolved));
+    return null;
+  } catch {
+    return resolved;
+  }
+}
+var RUN_TIMEOUT_EXIT_CODE = 124;
+function armRunTimeout(seconds) {
+  const coordinator = getTerminationCoordinator();
+  let expired = false;
+  const timer = setTimeout(
+    () => {
+      if (coordinator.getPhase() !== "idle") return;
+      expired = true;
+      process.stderr.write(`clio-coder run: --timeout ${seconds}s elapsed; shutting down
+`);
+      void coordinator.shutdown(RUN_TIMEOUT_EXIT_CODE);
+    },
+    Math.ceil(seconds * 1e3)
+  );
+  timer.unref();
+  return { seconds, expired: () => expired, settle: () => clearTimeout(timer) };
+}
+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 !readStrictLayeredSettings(process.cwd()).settings.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 headlessSlashPreflight(task) {
+  if (!task.trim().startsWith("/")) return null;
+  const { parseSlashCommand } = await import("./slash-commands-ROG3KIFJ.js");
+  const command = parseSlashCommand(task);
+  if (command.kind === "skill-invocation" || command.kind === "unknown" || command.kind === "empty") return null;
+  if (command.kind !== "unknown-command") {
+    return {
+      refusal: "interactive commands are not supported by clio-coder run; use interactive chat or the corresponding CLI command"
+    };
+  }
+  const { expandPromptTemplateInput, loadPromptTemplates } = await import("./resources-FY6XYFN2.js");
+  const templates = loadPromptTemplates({ cwd: process.cwd() });
+  if (!templates.items.some((template) => template.name === command.token)) {
+    return { refusal: `/${command.token} is not a command. Type /help for the list.` };
+  }
+  const expansion = expandPromptTemplateInput(task, templates);
+  if (expansion.expanded === false && expansion.display) return { display: expansion.display.text };
+  return null;
+}
+async function runClioRun(args, options = {}) {
+  const parsed = parseRunCliArgs(args);
+  return withRunOverrides(
+    {
+      ...parsed.maxContextTokens !== void 0 ? { maxContextTokens: parsed.maxContextTokens } : {}
+    },
+    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.constraints && parsed.agentId !== void 0) {
+        process.stderr.write(
+          "clio-coder run: --turn-mode, --allow-tools, and --no-delegate apply to the main-agent task\n"
+        );
+        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;
+      }
+      if (parsed.failOnNoop && parsed.agentId !== void 0) {
+        process.stderr.write("clio-coder run: --fail-on-noop applies to the main agent, not --agent dispatch\n");
+        process.stderr.write(USAGE);
+        return 2;
+      }
+      if (parsed.timeoutSeconds !== void 0 && parsed.agentId !== void 0) {
+        process.stderr.write("clio-coder run: --timeout applies to the main agent, not --agent dispatch\n");
+        process.stderr.write(USAGE);
+        return 2;
+      }
+      const deadline = parsed.timeoutSeconds === void 0 ? void 0 : armRunTimeout(parsed.timeoutSeconds);
+      try {
+        if (parsed.cwd !== void 0) {
+          const unusable = enterRunCwd(parsed.cwd);
+          if (unusable !== null) {
+            process.stderr.write(`clio-coder run: --cwd is not a directory this process can enter: ${unusable}
+`);
+            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) {
+          const preflight = await headlessSlashPreflight(assembled.prompt);
+          if (preflight !== null && "refusal" in preflight) {
+            process.stderr.write(`clio-coder run: ${preflight.refusal}
+`);
+            return 2;
+          }
+          if (preflight !== null) {
+            process.stdout.write(`${preflight.display}
+`);
+            return 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,
+                ...parsed.constraints ? { constraints: parsed.constraints } : {},
+                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.failOnNoop ? { failOnNoop: true } : {},
+                ...deadline !== void 0 ? { deadline } : {},
+                ...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
+        });
+      } finally {
+        deadline?.settle();
+      }
+    }
+  );
+}
+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,
+      // This path iterates `handle.events` itself and builds no dispatch
+      // event registry, so the domain is the only thing that can write the
+      // run's durable transcript.
+      journalRunEvents: true
+    }),
+    LifecycleDomainModule
+  ]);
+  const config = loaded.getContract("config");
+  const baseSettings = config?.get() ?? readSettings();
+  configureRunEventJournal(baseSettings.fleet.history.journal);
+  effectiveSettings = structuredClone(baseSettings);
+  if (parsed.autonomy !== void 0) effectiveSettings.safety.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.fleet?.profiles?.[parsed.agentProfile]?.target : void 0;
+    const runtimeByTarget = new Map(settings.targets.map((target2) => [target2.id, target2.runtime]));
+    const runtimeTargetId = parsed.agentRuntime ? [settings.fleet?.default, ...Object.values(settings.fleet?.profiles ?? {})].find(
+      (profile) => profile?.target && runtimeByTarget.get(profile.target) === parsed.agentRuntime
+    )?.target : void 0;
+    const targetId = parsed.target ?? profileTargetId ?? runtimeTargetId ?? settings.fleet?.default?.target ?? settings.chat?.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.integrations.projectResources?.trustProjectImports) {
+      dispatchReq.trustProjectCompatRoots = true;
+    }
+  } catch {
+  }
+  let memorySection = "";
+  try {
+    const records = loadMemoryRecordsSync(clioDataDir());
+    const boundProfileName = parsed.agentProfile ?? effectiveSettings.fleet.agentProfiles[parsed.agentId];
+    const boundProfile = boundProfileName ? effectiveSettings.fleet.profiles[boundProfileName] : void 0;
+    const configuredRuntime = (targetId) => effectiveSettings.targets.find((target) => target.id === targetId)?.runtime;
+    const profileRuntimeId = configuredRuntime(boundProfile?.target);
+    const memoryRuntimeId = parsed.target !== void 0 ? configuredRuntime(parsed.target) : boundProfileName !== void 0 ? parsed.agentRuntime === profileRuntimeId ? profileRuntimeId : void 0 : parsed.agentRuntime;
+    memorySection = buildMemoryPromptSection(records, {
+      scopes: ["global", "repo", "runtime", "agent"],
+      activeRepository: canonicalMemoryRepositoryIdentity(process.cwd()),
+      activeRuntime: memoryRuntimeId === void 0 ? null : { kind: "runtime", key: memoryRuntimeId },
+      activeAgent: { kind: "agent", key: parsed.agentId }
+    }).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}` : "";
+  const responseModelIdObservation = receiptResponseModelIdObservationLabel(r);
+  const gatewayRouting = receiptGatewayRoutingLabel(r);
+  return `receipt: ${r.runId} agent=${r.agentId} exit=${r.exitCode} target=${r.targetId} requested_model_id=${r.wireModelId}${responseModelIdObservation ? ` ${responseModelIdObservation}` : ""}${gatewayRouting ? ` ${gatewayRouting}` : ""} 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 {
+  explicitTargetMissing,
+  runClioRun
+};
+//# sourceMappingURL=run-H64MEVTA.js.map