chainlesschain 0.162.162 → 0.162.164

package/src/commands/agenda.js

@@ -7,20 +7,26 @@
  *   cc agenda list [--json]           show all scheduled entries
  *   cc agenda run [--json] [--dry-run]  fire everything due right now
  *   cc agenda cancel <id>             remove one entry
+ *   cc agenda prune [--older-than N]  drop finished entries
  *
  * `run` for each due entry:
  *   - wakeup  → spawn `cc agent -p <prompt>`, mark fired
  *   - cron    → spawn `cc agent -p <prompt>`, advance to next fire time
- *   - monitor → run <command>; if output matches stop_when, send the
- *               notification and stop; else re-arm for the next interval
+ *   - monitor → check its source (a shell <command>'s output, a <watchFile>'s
+ *               content / appearance / modification, or a <watchUrl>'s response
+ *               body / 2xx); if it matches stop_when, send the notification and
+ *               stop; else re-arm for the next interval
  */
 
 import { spawn, execSync } from "node:child_process";
+import { readFileSync, statSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import chalk from "chalk";
 import { AgentScheduleStore } from "../lib/agent-schedule-store.js";
 import { sendAgentNotification } from "../lib/agent-notify.js";
-import { nextWakeupAt } from "../lib/schedule-planner.js";
+import { nextWakeupAt, partitionSchedule } from "../lib/schedule-planner.js";
+import { monitorEventEnvelope, capEventPayload } from "../lib/monitor-event.js";
+import { unattendedDisallowedTools } from "../lib/unattended-action-policy.js";
 
 const BIN_PATH = fileURLToPath(
   new URL("../../bin/chainlesschain.js", import.meta.url),
@@ -58,6 +64,20 @@ export function registerAgendaCommand(program) {
     .action((id, options) => {
       process.exitCode = runAgendaCancel(id, options);
     });
+
+  cmd
+    .command("prune")
+    .description(
+      "Remove finished entries (fired / matched / exhausted / expired)",
+    )
+    .option(
+      "--older-than <seconds>",
+      "Only prune entries that finished more than N seconds ago",
+    )
+    .option("--json", "Machine-readable JSON output")
+    .action((options) => {
+      process.exitCode = runAgendaPrune(options);
+    });
 }
 
 export function runAgendaList(options = {}, _deps = {}) {
@@ -80,17 +100,30 @@ export function runAgendaList(options = {}, _deps = {}) {
   log("");
   log(chalk.bold("  Agenda:\n"));
   for (const e of entries) {
+    const monitorWhat =
+      e.source === "file"
+        ? `file ${e.watchFile}`
+        : e.source === "http"
+          ? `url ${e.watchUrl}`
+          : `every ${Math.round(e.intervalMs / 1000)}s`;
     const when =
       e.kind === "wakeup"
         ? new Date(e.dueAt).toISOString()
         : e.kind === "cron"
           ? `${e.cron} (next ${new Date(e.nextAt).toISOString()})`
-          : `every ${Math.round(e.intervalMs / 1000)}s (next ${new Date(e.nextAt).toISOString()})`;
+          : `${monitorWhat} (next ${new Date(e.nextAt).toISOString()})`;
+    const expiry =
+      e.expiresAt != null
+        ? chalk.dim(` · expires ${new Date(e.expiresAt).toISOString()}`)
+        : "";
+    const policy = e.runPolicy
+      ? chalk.dim(` · ${describePolicy(e.runPolicy)}`)
+      : "";
     log(
       `  ${chalk.cyan(e.kind.padEnd(8))} ${chalk.dim(e.id.slice(0, 8))} ` +
-        `${statusBadge(e.status)}  ${e.label || truncate(e.prompt || e.command, 40)}`,
+        `${statusBadge(e.status)}  ${e.label || truncate(e.prompt || e.command || e.watchFile || e.watchUrl, 40)}`,
     );
-    log(`           ${chalk.dim(when)}`);
+    log(`           ${chalk.dim(when)}${expiry}${policy}`);
   }
   if (nextAt != null) {
     const rel = Math.max(0, Math.round((nextAt - now) / 1000));
@@ -120,6 +153,54 @@ export function runAgendaCancel(id, options = {}, _deps = {}) {
   return 2;
 }
 
+/**
+ * Remove finished (terminal) entries so the store does not grow without bound.
+ * `--older-than <seconds>` keeps entries that finished more recently.
+ */
+export function runAgendaPrune(options = {}, _deps = {}) {
+  const log = _deps.log || ((m) => console.log(m));
+  const store = _deps.store || new AgentScheduleStore();
+  const now = _deps.now ? _deps.now() : Date.now();
+
+  let before = Infinity;
+  if (options.olderThan != null) {
+    const secs = Number(options.olderThan);
+    if (!Number.isFinite(secs) || secs < 0) {
+      log(chalk.red(`\n  ✖ invalid --older-than: ${options.olderThan}\n`));
+      return 2;
+    }
+    before = now - secs * 1000;
+  }
+
+  const removed = store.pruneTerminal({ before });
+  if (options.json) {
+    log(
+      JSON.stringify(
+        {
+          pruned: removed.map((e) => ({
+            id: e.id,
+            kind: e.kind,
+            status: e.status,
+          })),
+        },
+        null,
+        2,
+      ),
+    );
+    return 0;
+  }
+  if (removed.length === 0) {
+    log(chalk.gray("\n  No finished entries to prune.\n"));
+    return 0;
+  }
+  log(
+    chalk.green(
+      `\n  ✓ Pruned ${removed.length} finished entr${removed.length === 1 ? "y" : "ies"}\n`,
+    ),
+  );
+  return 0;
+}
+
 /**
  * Fire due entries. Returns 0 unless a monitor command / agent spawn failed in
  * a way worth signalling; JSON summary lists every action taken.
@@ -129,8 +210,16 @@ export async function runAgendaRun(options = {}, _deps = {}) {
   const store = _deps.store || new AgentScheduleStore();
   const spawnAgent = _deps.spawnAgent || defaultSpawnAgent;
   const runCommand = _deps.runCommand || defaultRunCommand;
+  const readWatchedFile = _deps.readWatchedFile || defaultReadWatchedFile;
+  const fetchUrl = _deps.fetchUrl || defaultFetchUrl;
   const notify = _deps.notify || sendAgentNotification;
-  const due = store.due(null, _deps.now ? _deps.now() : null);
+  const now = _deps.now ? _deps.now() : Date.now();
+  // Retire expired entries BEFORE firing due ones — an expired task never gets
+  // a final fire (schedule-planner semantics). Dry-run inspects without mutating.
+  const retired = options.dryRun
+    ? partitionSchedule(store.list(), { now }).expired
+    : store.retireExpired(now);
+  const due = store.due(null, now);
   const actions = [];
 
   for (const entry of due) {
@@ -140,32 +229,112 @@ export async function runAgendaRun(options = {}, _deps = {}) {
     }
     try {
       if (entry.kind === "wakeup") {
-        await spawnAgent(entry.prompt);
+        await spawnAgent(entry.prompt, entry.runPolicy);
         store.markWakeupFired(entry.id);
         actions.push({ id: entry.id, kind: "wakeup", action: "fired" });
       } else if (entry.kind === "cron") {
-        await spawnAgent(entry.prompt);
+        await spawnAgent(entry.prompt, entry.runPolicy);
         store.advanceCron(entry.id);
         actions.push({ id: entry.id, kind: "cron", action: "fired" });
       } else if (entry.kind === "monitor") {
-        const output = await runCommand(entry.command);
-        const matched = entry.stopWhen
-          ? new RegExp(entry.stopWhen).test(output)
-          : false;
+        // Three sources: a shell command (match its output), a watched file
+        // (match its content, or — with no stopWhen — fire when it appears),
+        // or an HTTP endpoint (match its response body, or fire on 2xx).
+        let output = "";
+        let matched = false;
+        let mtimeMs = null;
+        if (entry.source === "file") {
+          const file = await readWatchedFile(entry.watchFile);
+          output = file.content;
+          mtimeMs = file.mtimeMs ?? null;
+          if (entry.watchChange) {
+            // Fire once the file's mtime advances past the baseline recorded on
+            // the first check. The first check only establishes the baseline.
+            matched =
+              entry.lastMtimeMs != null &&
+              mtimeMs != null &&
+              mtimeMs > entry.lastMtimeMs;
+          } else {
+            matched = entry.stopWhen
+              ? new RegExp(entry.stopWhen).test(file.content)
+              : file.exists; // no pattern → the file appearing is the signal
+          }
+        } else if (entry.source === "http") {
+          const res = await fetchUrl(entry.watchUrl);
+          output = res.body;
+          matched = entry.stopWhen
+            ? new RegExp(entry.stopWhen).test(res.body)
+            : res.ok; // no pattern → a 2xx response is the signal
+        } else {
+          output = await runCommand(entry.command);
+          matched = entry.stopWhen
+            ? new RegExp(entry.stopWhen).test(output)
+            : false;
+        }
         if (matched) {
-          await notify({
-            title: entry.notify?.title || `Monitor matched: ${entry.command}`,
-            body: truncate(output, 500),
-            level: "success",
+          const what =
+            entry.source === "file"
+              ? entry.watchFile
+              : entry.source === "http"
+                ? entry.watchUrl
+                : entry.command;
+          // Stamp the firing with the shared delivery guarantees (monitor-event.js):
+          // a deterministic event_id (audit identity, RNG-free) + a SYSTEM
+          // authority envelope (steer only — a monitor firing can NEVER answer a
+          // permission gate) + a byte-safe payload cap.
+          const envelope = monitorEventEnvelope(
+            entry.id,
+            { what, output },
+            { at: now, source: entry.source },
+          );
+          // At-most-once dedup: a persisted lastEventId equal to this event_id
+          // means this exact observation already fired (e.g. a resident daemon
+          // re-observing the same state) — record but do not re-notify.
+          const duplicate =
+            entry.lastEventId != null &&
+            entry.lastEventId === envelope.event_id;
+          // Persist the firing (status→matched + event_id + authority audit)
+          // BEFORE the notification side-effect so the record is durable even if
+          // the alert delivery fails; delivery itself is best-effort.
+          const updated = store.recordMonitorCheck(entry.id, {
+            matched: true,
+            mtimeMs,
+            eventId: envelope.event_id,
+            authority: envelope.authority,
+          });
+          const action = {
+            id: entry.id,
+            kind: "monitor",
+            action: duplicate ? "duplicate" : "matched",
+            status: updated?.status,
+            event_id: envelope.event_id,
+            authority: envelope.authority,
+          };
+          if (envelope.truncated) action.truncated = true;
+          if (!duplicate) {
+            try {
+              await notify({
+                title: entry.notify?.title || `Monitor matched: ${what}`,
+                body: capEventPayload(output, 500).value,
+                level: "success",
+              });
+            } catch (notifyErr) {
+              action.notifyError = notifyErr.message;
+            }
+          }
+          actions.push(action);
+        } else {
+          const updated = store.recordMonitorCheck(entry.id, {
+            matched: false,
+            mtimeMs,
+          });
+          actions.push({
+            id: entry.id,
+            kind: "monitor",
+            action: "checked",
+            status: updated?.status,
           });
         }
-        const updated = store.recordMonitorCheck(entry.id, { matched });
-        actions.push({
-          id: entry.id,
-          kind: "monitor",
-          action: matched ? "matched" : "checked",
-          status: updated?.status,
-        });
       }
     } catch (err) {
       actions.push({
@@ -177,11 +346,25 @@ export async function runAgendaRun(options = {}, _deps = {}) {
     }
   }
 
+  const retiredSummary = retired.map((e) => ({ id: e.id, kind: e.kind }));
   if (options.json) {
-    log(JSON.stringify({ due: due.length, actions }, null, 2));
-  } else if (actions.length === 0) {
+    log(
+      JSON.stringify(
+        { due: due.length, retired: retiredSummary, actions },
+        null,
+        2,
+      ),
+    );
+  } else if (actions.length === 0 && retired.length === 0) {
     log(chalk.gray("  Nothing due.\n"));
   } else {
+    for (const e of retired) {
+      log(
+        chalk.gray(
+          `  ${e.kind} ${e.id.slice(0, 8)}: ${options.dryRun ? "would-expire" : "expired"}`,
+        ),
+      );
+    }
     for (const a of actions) {
       const colour = a.action === "error" ? chalk.red : chalk.green;
       log(colour(`  ${a.kind} ${a.id.slice(0, 8)}: ${a.action}`));
@@ -192,13 +375,72 @@ export async function runAgendaRun(options = {}, _deps = {}) {
 
 // ─── default effectful deps (overridable in tests) ─────────────────────────
 
-function defaultSpawnAgent(prompt) {
+/**
+ * Build the `cc agent` argv for a scheduled prompt, appending the entry's
+ * per-task run policy as real `cc agent` flags. A missing / empty policy adds
+ * nothing, so an unpolicied task spawns exactly `cc agent -p <prompt>` as
+ * before (byte-identical). Exported for unit tests.
+ */
+export function buildAgentArgs(prompt, policy = null) {
+  const args = ["agent", "-p", prompt];
+  // P1-8: a scheduled run is UNATTENDED — deny high-risk external tools
+  // (publish_artifact / notify) by default so no timer-fired agent can publish
+  // or message outward on its own. A task opts specific action classes back in
+  // via runPolicy.unattendedAllowlist; those tools are then NOT disallowed.
+  const disallow = unattendedDisallowedTools({
+    attended: false,
+    allowlist:
+      policy && Array.isArray(policy.unattendedAllowlist)
+        ? policy.unattendedAllowlist
+        : [],
+  });
+  if (disallow.length > 0) {
+    args.push("--disallowed-tools", disallow.join(","));
+  }
+  if (policy && typeof policy === "object") {
+    if (
+      typeof policy.permissionMode === "string" &&
+      policy.permissionMode.length > 0
+    ) {
+      args.push("--permission-mode", policy.permissionMode);
+    }
+    if (policy.worktree === true) args.push("--worktree");
+    if (Number.isFinite(policy.maxTurns) && policy.maxTurns > 0) {
+      args.push("--max-turns", String(policy.maxTurns));
+    }
+    if (
+      typeof policy.goalCondition === "string" &&
+      policy.goalCondition.length > 0
+    ) {
+      args.push("--goal-condition", policy.goalCondition);
+      if (Number.isFinite(policy.maxOuterTurns) && policy.maxOuterTurns > 0) {
+        args.push("--max-outer-turns", String(policy.maxOuterTurns));
+      }
+      if (Number.isFinite(policy.goalMaxTokens) && policy.goalMaxTokens > 0) {
+        args.push("--goal-max-tokens", String(policy.goalMaxTokens));
+      }
+      if (Number.isFinite(policy.goalMaxCost) && policy.goalMaxCost > 0) {
+        args.push("--goal-max-cost", String(policy.goalMaxCost));
+      }
+      if (Number.isFinite(policy.goalMaxTime) && policy.goalMaxTime > 0) {
+        args.push("--goal-max-time", String(policy.goalMaxTime));
+      }
+    }
+  }
+  return args;
+}
+
+function defaultSpawnAgent(prompt, policy = null) {
   return new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, [BIN_PATH, "agent", "-p", prompt], {
-      stdio: "ignore",
-      detached: false,
-      env: process.env,
-    });
+    const child = spawn(
+      process.execPath,
+      [BIN_PATH, ...buildAgentArgs(prompt, policy)],
+      {
+        stdio: "ignore",
+        detached: false,
+        env: process.env,
+      },
+    );
     child.on("error", reject);
     child.on("close", (code) =>
       code === 0 || code == null
@@ -221,6 +463,40 @@ function defaultRunCommand(command) {
   }
 }
 
+/**
+ * Read a watched file → { exists, content, mtimeMs }. A missing file is not an
+ * error. mtimeMs feeds watchChange monitors (fire when the file is modified).
+ */
+function defaultReadWatchedFile(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    let mtimeMs = null;
+    try {
+      mtimeMs = statSync(filePath).mtimeMs;
+    } catch {
+      /* content read but stat failed — treat mtime as unknown */
+    }
+    return { exists: true, content, mtimeMs };
+  } catch {
+    return { exists: false, content: "", mtimeMs: null };
+  }
+}
+
+/**
+ * GET a watched URL → { ok, status, body }. Any failure (network, timeout,
+ * non-2xx) is not an error here — it just yields ok:false so the monitor
+ * re-arms and tries again next interval.
+ */
+async function defaultFetchUrl(url) {
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(30000) });
+    const body = await res.text();
+    return { ok: res.ok, status: res.status, body };
+  } catch {
+    return { ok: false, status: 0, body: "" };
+  }
+}
+
 function statusBadge(status) {
   switch (status) {
     case "pending":
@@ -231,6 +507,8 @@ function statusBadge(status) {
       return chalk.cyan(status);
     case "exhausted":
       return chalk.yellow(status);
+    case "expired":
+      return chalk.gray(status);
     default:
       return status;
   }
@@ -240,3 +518,13 @@ function truncate(text, n) {
   const s = String(text || "");
   return s.length > n ? s.slice(0, n) + "…" : s;
 }
+
+/** Compact human summary of a scheduled entry's per-task run policy. */
+function describePolicy(policy) {
+  const parts = [];
+  if (policy.permissionMode) parts.push(policy.permissionMode);
+  if (policy.worktree === true) parts.push("worktree");
+  if (Number.isFinite(policy.maxTurns)) parts.push(`≤${policy.maxTurns} turns`);
+  if (policy.goalCondition) parts.push(`goal: ${policy.goalCondition}`);
+  return parts.join(", ");
+}

package/src/commands/agent.js

@@ -204,6 +204,10 @@ export function registerAgentCommand(program) {
       "--otlp <file>",
       "Write the agent run's OpenTelemetry spans (model/tool/retry) as OTLP/JSON to <file>",
     )
+    .option(
+      "--otlp-content",
+      "Include prompt/response CONTENT in --otlp spans (off by default; content is redacted unless this is set)",
+    )
     .option(
       "--auto-rewake",
       "When an async `asyncRewake` hook (e.g. a background test) fails at turn end, re-engage the agent to fix it (bounded by --max-rewakes)",
@@ -311,6 +315,30 @@ export function registerAgentCommand(program) {
       "--goal-assess",
       "After the run, ask the model to assess goal progress and persist it (opt-in; costs one extra completion; requires --goal)",
     )
+    .option(
+      "--goal-condition <spec>",
+      "Session completion condition; re-drives outer turns until met. Prefix exit-zero:/file-exists:/contains:/regex: (deterministic) or model:<desc> (model-judged)",
+    )
+    .option(
+      "--max-outer-turns <n>",
+      "Max outer re-drive turns for --goal-condition (default 10, hard cap 100)",
+      (v) => parseInt(v, 10),
+    )
+    .option(
+      "--goal-max-tokens <n>",
+      "Token budget across --goal-condition outer turns",
+      (v) => parseInt(v, 10),
+    )
+    .option(
+      "--goal-max-cost <usd>",
+      "Cost budget (USD) across --goal-condition outer turns",
+      (v) => parseFloat(v),
+    )
+    .option(
+      "--goal-max-time <ms>",
+      "Wall-clock budget (ms) across --goal-condition outer turns",
+      (v) => parseInt(v, 10),
+    )
     .option(
       "--mcp-config <file>",
       "Load ad-hoc MCP servers from a JSON file for this run (headless); their tools become callable (mcp__<server>__<tool>)",
@@ -871,6 +899,11 @@ export function registerAgentCommand(program) {
             maxCostUsd,
             priceTable,
             chatFn: fallbackChatFn,
+            // --json-schema: structured output for stream-INPUT mode. The schema
+            // is resolved + meta-validated up front, its output contract injected
+            // into the system prompt, and a per-turn `structured_result` event is
+            // appended after each turn (parity with single-prompt --json-schema).
+            jsonSchema: options.jsonSchema || null,
           });
         } catch (err) {
           process.stderr.write(`Error: ${err.message}\n`);
@@ -1001,6 +1034,19 @@ export function registerAgentCommand(program) {
         }
         const { runAgentHeadless, parseToolList } =
           await import("../runtime/headless-runner.js");
+        // --goal-condition: validate the spec up front so a bad prefix fails
+        // fast (before any model call) with a clear message.
+        if (options.goalCondition) {
+          try {
+            const { parseGoalCondition } =
+              await import("../lib/goal-condition-engine.js");
+            parseGoalCondition(options.goalCondition);
+          } catch (e) {
+            process.stderr.write(`--goal-condition: ${e.message}\n`);
+            await _finishWorktree();
+            process.exit(1);
+          }
+        }
         const maxTurns = options.maxTurns
           ? parseInt(options.maxTurns, 10)
           : undefined;
@@ -1027,6 +1073,9 @@ export function registerAgentCommand(program) {
           autoCheckpoint,
           // --otlp <file>: capture + export the run's OTel spans as OTLP/JSON.
           otlp: options.otlp || null,
+          // --otlp-content: opt in to emitting prompt/response CONTENT in those
+          // spans. Default false → content stays redacted (privacy by default).
+          otlpContent: options.otlpContent === true,
           // --auto-rewake / --max-rewakes: bounded re-drive on async-hook failure.
           // --max-rewakes implies --auto-rewake (a positive budget turns it on).
           autoRewake:
@@ -1052,6 +1101,21 @@ export function registerAgentCommand(program) {
           goal: options.goal,
           // --goal-assess: run-end LLM progress assessment (Phase 2)
           goalAssess: options.goalAssess === true,
+          // --goal-condition: session-level completion-condition engine — drives
+          // outer turns until the condition is met or a budget is exhausted.
+          goalCondition: options.goalCondition || null,
+          maxOuterTurns: Number.isFinite(options.maxOuterTurns)
+            ? options.maxOuterTurns
+            : undefined,
+          goalMaxTokens: Number.isFinite(options.goalMaxTokens)
+            ? options.goalMaxTokens
+            : undefined,
+          goalMaxCostUsd: Number.isFinite(options.goalMaxCost)
+            ? options.goalMaxCost
+            : undefined,
+          goalMaxTimeMs: Number.isFinite(options.goalMaxTime)
+            ? options.goalMaxTime
+            : undefined,
           // --mcp-config: connect ad-hoc MCP servers + expose their tools
           mcpConfig: options.mcpConfig || null,
           // --no-mcp: skip registered (cc mcp add) auto-connect servers
@@ -1081,21 +1145,51 @@ export function registerAgentCommand(program) {
           chatFn: fallbackChatFn,
         };
 
-        // --json-schema: structured output 鈥?wrap the runner with capture +
-        // validate + retry (json-schema-output.js); prints only the
-        // validated JSON. Incompatible with stream-json (event stream and a
-        // single JSON contract don't mix).
+        // --json-schema: structured output. Accepts a file path OR inline JSON.
+        //  - text/json output: wrap the runner with capture + validate + retry
+        //    (json-schema-output.js); prints only the validated JSON.
+        //  - stream-json output: stream events normally, then emit a terminal
+        //    `structured_result` event (schema_digest + valid + value/errors) as
+        //    the last NDJSON line, so the two protocols are now compatible.
         if (options.jsonSchema) {
+          const jso = await import("../lib/json-schema-output.js");
           if (options.outputFormat === "stream-json") {
-            process.stderr.write(
-              "--json-schema is incompatible with --output-format stream-json.\n",
-            );
-            process.exit(1);
+            try {
+              const schema = jso.loadSchemaFile(
+                jso._deps.fs,
+                options.jsonSchema,
+              );
+              const instruction = jso.buildSchemaInstruction(schema);
+              const outcome = await runAgentHeadless({
+                ...headlessOptions,
+                appendSystemPrompt: [
+                  headlessOptions.appendSystemPrompt,
+                  instruction,
+                ]
+                  .filter(Boolean)
+                  .join("\n\n"),
+              });
+              // The normal stream (init … result) has already been written to
+              // stdout by the runner. Append the structured verdict as the final
+              // NDJSON line, built from the run's final text.
+              const parsed = jso.extractJsonPayload(
+                String(outcome?.result ?? ""),
+              );
+              const evt = jso.buildStructuredResult(
+                schema,
+                parsed.ok ? parsed.value : null,
+              );
+              process.stdout.write(JSON.stringify(evt) + "\n");
+              await _finishWorktree();
+              process.exit(evt.valid ? 0 : 1);
+            } catch (err) {
+              process.stderr.write(`Error: ${err.message}\n`);
+              await _finishWorktree();
+              process.exit(1);
+            }
           }
           try {
-            const { runJsonSchemaConstrained } =
-              await import("../lib/json-schema-output.js");
-            const code = await runJsonSchemaConstrained({
+            const code = await jso.runJsonSchemaConstrained({
               schemaFile: options.jsonSchema,
               baseOptions: headlessOptions,
               runHeadless: runAgentHeadless,