@namzu/cli 35.0.0 → 36.1.0

package/dist/chunks/exec-COV235L5.js

@@ -0,0 +1,1284 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+import {
+  expandHeadlessCommand,
+  hostCommandNames
+} from "./chunk-N5IF64K3.js";
+import {
+  withTerminationHandling
+} from "./chunk-7WJOQ6EA.js";
+import "./chunk-TBIX6JRE.js";
+import {
+  loadOutputSchema
+} from "./chunk-AXIGFKJF.js";
+import "./chunk-JV3LONAU.js";
+import {
+  decideHeadlessTrust
+} from "./chunk-C5WBEO3X.js";
+import "./chunk-PYG7DZ2D.js";
+import "./chunk-JPPC4LJF.js";
+import "./chunk-KU3W6IHV.js";
+import "./chunk-HE7WUOX2.js";
+import {
+  resolveTrustedProjectContext
+} from "./chunk-CHIEVVQ2.js";
+import "./chunk-US5ZFPAU.js";
+import "./chunk-6LLJQ3KY.js";
+import {
+  EXIT_FAIL,
+  EXIT_OK,
+  EXIT_UNTRUSTED,
+  EXIT_USAGE
+} from "./chunk-Y7B67G22.js";
+import {
+  applyProviderFlags,
+  buildGate,
+  loadSkillsContext,
+  parseExecFlags,
+  resolveWorkingDirectory,
+  unknownOptionMessage
+} from "./chunk-HFJHHCTY.js";
+import {
+  duration,
+  pauseWait
+} from "./chunk-XEUQN4JC.js";
+import {
+  compilePermissions,
+  warnLegacyMcpPermissionNames
+} from "./chunk-Q5YM2GCX.js";
+import {
+  describeTurnInterruption,
+  retryAfterMs
+} from "./chunk-WM2JEUGV.js";
+import {
+  cliLogger,
+  contextLogging,
+  createStderrSink,
+  installCliLogging
+} from "./chunk-HBBB2CAC.js";
+import "./chunk-EEDZOGV4.js";
+import {
+  resolvePermissionMode
+} from "./chunk-5GRV6P5C.js";
+import {
+  attachSessionExport
+} from "./chunk-FTMTO72X.js";
+import "./chunk-LXB3S4IC.js";
+import "./chunk-OH6TB27S.js";
+import {
+  closeSessions,
+  listRecent,
+  loadConversation,
+  loadResumableConversation,
+  openSessions,
+  resolveConversation,
+  startConversation
+} from "./chunk-TIGWWAJI.js";
+import "./chunk-H6B6AROX.js";
+import "./chunk-A5UXODFL.js";
+import "./chunk-OLPOM3DR.js";
+import "./chunk-CG65NUSJ.js";
+import "./chunk-JORONMD3.js";
+import "./chunk-Q24K7536.js";
+import "./chunk-NQY5P2EB.js";
+import {
+  BOOT_EVENT_NAMES,
+  EVENT_NAME_ATTRIBUTE,
+  TurnCancelled,
+  asSessionId,
+  generateSessionId,
+  isCompactionMessage,
+  isModelContentOmission,
+  isProjectInstructionMessageSource,
+  isRuntimeContextMessageSource,
+  isWorkingMemoryMessage,
+  jsonLinesSink
+} from "./chunk-EWKJGHRO.js";
+import {
+  __name
+} from "./chunk-76FLAFCG.js";
+
+// src/commands/exec.ts
+import { relative, resolve } from "node:path";
+
+// src/commands/prior-messages.ts
+var isObject = /* @__PURE__ */ __name((value) => typeof value === "object" && value !== null && !Array.isArray(value), "isObject");
+var isFiniteNumber = /* @__PURE__ */ __name((value) => typeof value === "number" && Number.isFinite(value), "isFiniteNumber");
+function optional(value, key, path, accepts, expected) {
+  const candidate = value[key];
+  return candidate === void 0 || accepts(candidate) ? null : `${path}.${key} must be ${expected}`;
+}
+__name(optional, "optional");
+function stringField(value, key, path) {
+  return typeof value[key] === "string" ? null : `${path}.${key} must be a string`;
+}
+__name(stringField, "stringField");
+function validateCommon(value, path) {
+  return (
+    // A string, not a checked `MessageId`: this file validates spelling
+    // the same way it already does for `toolCalls[].id`, never provenance
+    // — `query()`'s own reconciliation is what tells an id this log
+    // actually recorded from one a host invented, refusing the latter as
+    // `stale_cached_history` (`'foreign'`) rather than trusting it here.
+    // Keeping it (not stripping it) is what lets a host that reads its
+    // prior turn back from `namzu history --session <key>` (which DOES
+    // carry the real durable id) feed that same history into a stateless
+    // `exec --json` call and have it reconcile by id.
+    optional(value, "id", path, (candidate) => typeof candidate === "string", "a string") ?? optional(value, "timestamp", path, isFiniteNumber, "a finite number") ?? optional(
+      value,
+      "cacheHint",
+      path,
+      (candidate) => candidate === "cache" || candidate === "ephemeral" || candidate === "none",
+      '"cache", "ephemeral", or "none"'
+    ) ?? optional(value, "retain", path, (candidate) => typeof candidate === "boolean", "a boolean")
+  );
+}
+__name(validateCommon, "validateCommon");
+function validateAttachment(value, path) {
+  if (!isObject(value)) return `${path} must be an attachment object`;
+  const type = value.type;
+  if (type === "stored") {
+    return `${path} is a stored attachment reference, but stateless exec --json has no attachment store; send inline data instead`;
+  }
+  if (type === "document") {
+    return stringField(value, "data", path) ?? stringField(value, "mediaType", path) ?? optional(value, "name", path, (candidate) => typeof candidate === "string", "a string") ?? optional(value, "citations", path, (candidate) => typeof candidate === "boolean", "a boolean");
+  }
+  if (type !== void 0 && type !== "image") {
+    return `${path}.type must be "image", "document", "stored", or absent`;
+  }
+  return stringField(value, "data", path) ?? stringField(value, "mediaType", path) ?? optional(
+    value,
+    "modelOmission",
+    path,
+    isModelContentOmission,
+    "a provider-rejected model-delivery marker"
+  );
+}
+__name(validateAttachment, "validateAttachment");
+function validateAttachments(value, path) {
+  if (!Array.isArray(value)) return `${path} must be an array`;
+  for (let index = 0; index < value.length; index++) {
+    const error = validateAttachment(value[index], `${path}[${index}]`);
+    if (error) return error;
+  }
+  return null;
+}
+__name(validateAttachments, "validateAttachments");
+function validateUserSource(value, path) {
+  if (!isObject(value)) return `${path} must be a source object`;
+  if (value.type === "project-instructions") {
+    return isProjectInstructionMessageSource(value) ? null : `${path} must contain unique canonical project-relative AGENTS.md paths`;
+  }
+  if (value.type === "runtime-context") {
+    return isRuntimeContextMessageSource(value) ? null : `${path} must contain an admitted runtime context kind`;
+  }
+  if (value.type !== "goal-round") {
+    return `${path}.type must be "goal-round", "project-instructions", or "runtime-context"`;
+  }
+  return stringField(value, "goalId", path) ?? stringField(value, "objective", path) ?? (isFiniteNumber(value.goalRevision) ? null : `${path}.goalRevision must be a finite number`) ?? (isFiniteNumber(value.round) ? null : `${path}.round must be a finite number`) ?? (isFiniteNumber(value.maxGoalRounds) ? null : `${path}.maxGoalRounds must be a finite number`);
+}
+__name(validateUserSource, "validateUserSource");
+function validateAssistantSource(value, path) {
+  if (!isObject(value)) return `${path} must be a source object`;
+  if (value.type !== "model") return `${path}.type must be "model"`;
+  return stringField(value, "providerId", path) ?? stringField(value, "model", path) ?? (Number.isSafeInteger(value.chainIndex) && value.chainIndex >= 0 ? null : `${path}.chainIndex must be a non-negative safe integer`);
+}
+__name(validateAssistantSource, "validateAssistantSource");
+var isCount = /* @__PURE__ */ __name((candidate) => Number.isSafeInteger(candidate) && candidate >= 0, "isCount");
+function validateInputError(value, path) {
+  if (!isObject(value)) return `${path} must be an object`;
+  return (value.reason === "truncated" || value.reason === "malformed" ? null : `${path}.reason must be "truncated" or "malformed"`) ?? optional(
+    value,
+    "finishReason",
+    path,
+    (candidate) => candidate === "stop" || candidate === "tool_calls" || candidate === "length" || candidate === "content_filter",
+    '"stop", "tool_calls", "length", or "content_filter"'
+  ) ?? stringField(value, "parseError", path) ?? optional(value, "offset", path, isCount, "a non-negative safe integer") ?? (isCount(value.length) ? null : `${path}.length must be a non-negative safe integer`) ?? (isCount(value.precedingLength) ? null : `${path}.precedingLength must be a non-negative safe integer`) ?? optional(
+    value,
+    "finishDetail",
+    path,
+    (candidate) => candidate === "context_window",
+    '"context_window"'
+  ) ?? optional(value, "outputTokens", path, isCount, "a non-negative safe integer") ?? optional(value, "reasoningTokens", path, isCount, "a non-negative safe integer");
+}
+__name(validateInputError, "validateInputError");
+function validateToolCall(value, path) {
+  if (!isObject(value)) return `${path} must be a tool-call object`;
+  const fn = value.function;
+  if (!isObject(fn)) return `${path}.function must be an object`;
+  const metadata = value.metadata;
+  return stringField(value, "id", path) ?? (value.type === "function" ? null : `${path}.type must be "function"`) ?? stringField(fn, "name", `${path}.function`) ?? stringField(fn, "arguments", `${path}.function`) ?? (metadata === void 0 ? null : !isObject(metadata) ? `${path}.metadata must be an object` : optional(
+    metadata,
+    "inputTruncated",
+    `${path}.metadata`,
+    (candidate) => typeof candidate === "boolean",
+    "a boolean"
+  ) ?? optional(
+    metadata,
+    "partialArguments",
+    `${path}.metadata`,
+    (candidate) => typeof candidate === "string",
+    "a string"
+  ) ?? (metadata.inputError === void 0 ? null : validateInputError(metadata.inputError, `${path}.metadata.inputError`)));
+}
+__name(validateToolCall, "validateToolCall");
+function validateReasoning(value, path) {
+  if (!isObject(value)) return `${path} must be a reasoning object`;
+  return (value.type === "thinking" || value.type === "redacted_thinking" ? null : `${path}.type must be "thinking" or "redacted_thinking"`) ?? optional(value, "text", path, (candidate) => typeof candidate === "string", "a string") ?? optional(value, "signature", path, (candidate) => typeof candidate === "string", "a string") ?? optional(value, "encrypted", path, (candidate) => typeof candidate === "string", "a string");
+}
+__name(validateReasoning, "validateReasoning");
+function validateCitation(value, path) {
+  if (!isObject(value)) return `${path} must be a citation object`;
+  const location = value.location;
+  if (!isObject(location)) return `${path}.location must be an object`;
+  return stringField(value, "citedText", path) ?? (isFiniteNumber(value.documentIndex) ? null : `${path}.documentIndex must be a finite number`) ?? optional(
+    value,
+    "documentTitle",
+    path,
+    (candidate) => typeof candidate === "string",
+    "a string"
+  ) ?? (location.kind === "page" || location.kind === "char" || location.kind === "block" ? null : `${path}.location.kind must be "page", "char", or "block"`) ?? (isFiniteNumber(location.start) ? null : `${path}.location.start must be a finite number`) ?? (isFiniteNumber(location.end) ? null : `${path}.location.end must be a finite number`);
+}
+__name(validateCitation, "validateCitation");
+function validateToolResultBlock(value, path) {
+  if (!isObject(value)) return `${path} must be a tool-result block object`;
+  if (value.type === "text") return stringField(value, "text", path);
+  if (value.type === "image") {
+    return stringField(value, "data", path) ?? stringField(value, "mediaType", path) ?? optional(
+      value,
+      "modelOmission",
+      path,
+      isModelContentOmission,
+      "a provider-rejected model-delivery marker"
+    );
+  }
+  if (value.type === "document") return validateAttachment(value, path);
+  return `${path}.type must be "text", "image", or "document"`;
+}
+__name(validateToolResultBlock, "validateToolResultBlock");
+function validateMessage(value, index) {
+  const path = `messages[${index}]`;
+  if (!isObject(value)) return `${path} must be an object`;
+  const common = validateCommon(value, path);
+  if (common) return common;
+  if (value.role === "system") {
+    if (typeof value.content !== "string") return `${path}.content must be a string`;
+    return isCompactionMessage(value.content) || isWorkingMemoryMessage(value.content) ? null : `${path} is an arbitrary system prompt; stateless history accepts only compacted or working-memory conversation state`;
+  }
+  if (value.role === "user") {
+    if (typeof value.content !== "string") return `${path}.content must be a string`;
+    return (value.attachments === void 0 ? null : validateAttachments(value.attachments, `${path}.attachments`)) ?? (value.source === void 0 ? null : validateUserSource(value.source, `${path}.source`));
+  }
+  if (value.role === "assistant") {
+    if (typeof value.content !== "string" && value.content !== null) {
+      return `${path}.content must be a string or null`;
+    }
+    if (value.toolCalls !== void 0) {
+      if (!Array.isArray(value.toolCalls)) return `${path}.toolCalls must be an array`;
+      for (let callIndex = 0; callIndex < value.toolCalls.length; callIndex++) {
+        const error = validateToolCall(
+          value.toolCalls[callIndex],
+          `${path}.toolCalls[${callIndex}]`
+        );
+        if (error) return error;
+      }
+    }
+    if (value.reasoning !== void 0) {
+      if (!Array.isArray(value.reasoning)) return `${path}.reasoning must be an array`;
+      for (let reasoningIndex = 0; reasoningIndex < value.reasoning.length; reasoningIndex++) {
+        const error = validateReasoning(
+          value.reasoning[reasoningIndex],
+          `${path}.reasoning[${reasoningIndex}]`
+        );
+        if (error) return error;
+      }
+    }
+    if (value.citations !== void 0) {
+      if (!Array.isArray(value.citations)) return `${path}.citations must be an array`;
+      for (let citationIndex = 0; citationIndex < value.citations.length; citationIndex++) {
+        const error = validateCitation(
+          value.citations[citationIndex],
+          `${path}.citations[${citationIndex}]`
+        );
+        if (error) return error;
+      }
+    }
+    return value.source === void 0 ? null : validateAssistantSource(value.source, `${path}.source`);
+  }
+  if (value.role === "tool") {
+    if (typeof value.content !== "string") {
+      if (!Array.isArray(value.content)) {
+        return `${path}.content must be a string or tool-result block array`;
+      }
+      for (let blockIndex = 0; blockIndex < value.content.length; blockIndex++) {
+        const error = validateToolResultBlock(
+          value.content[blockIndex],
+          `${path}.content[${blockIndex}]`
+        );
+        if (error) return error;
+      }
+    }
+    return stringField(value, "toolCallId", path) ?? optional(value, "isError", path, (candidate) => typeof candidate === "boolean", "a boolean");
+  }
+  return `${path}.role must be "system", "user", "assistant", or "tool"`;
+}
+__name(validateMessage, "validateMessage");
+function validateSequence(messages) {
+  const seenCallIds = /* @__PURE__ */ new Set();
+  let pending = null;
+  let sawConversation = false;
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index];
+    if (!message) continue;
+    if (pending) {
+      if (message.role !== "tool") {
+        return `messages[${index}] cannot appear before every tool call from messages[${pending.openedAt}] has a result`;
+      }
+      if (!pending.ids.has(message.toolCallId)) {
+        return `messages[${index}].toolCallId does not match an unanswered call from messages[${pending.openedAt}]`;
+      }
+      pending.ids.delete(message.toolCallId);
+      if (pending.ids.size === 0) pending = null;
+      continue;
+    }
+    if (message.role === "system") {
+      if (sawConversation) return `messages[${index}] is a system message after conversation began`;
+      continue;
+    }
+    if (!sawConversation) {
+      sawConversation = true;
+      if (message.role !== "user") {
+        return `messages[${index}] must be a user message at the start of conversation history`;
+      }
+    }
+    if (message.role === "tool") return `messages[${index}] is a tool result with no pending call`;
+    if (message.role !== "assistant" || !message.toolCalls || message.toolCalls.length === 0) {
+      continue;
+    }
+    const ids = /* @__PURE__ */ new Set();
+    for (let callIndex = 0; callIndex < message.toolCalls.length; callIndex++) {
+      const id = message.toolCalls[callIndex]?.id;
+      if (!id) continue;
+      if (seenCallIds.has(id) || ids.has(id)) {
+        return `messages[${index}].toolCalls[${callIndex}].id duplicates tool call id "${id}"`;
+      }
+      ids.add(id);
+      seenCallIds.add(id);
+    }
+    pending = { openedAt: index, ids };
+  }
+  if (pending) {
+    return `messages[${pending.openedAt}] has tool calls without immediate results for: ${[...pending.ids].join(", ")}`;
+  }
+  return null;
+}
+__name(validateSequence, "validateSequence");
+function parsePriorMessages(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return { ok: true, messages: [] };
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return { ok: false, error: "stdin history is not valid JSON" };
+  }
+  if (!Array.isArray(parsed)) {
+    return { ok: false, error: "stdin history must be a JSON Message[] array" };
+  }
+  for (let index = 0; index < parsed.length; index++) {
+    const error = validateMessage(parsed[index], index);
+    if (error) return { ok: false, error };
+  }
+  const messages = parsed;
+  const sequenceError = validateSequence(messages);
+  return sequenceError ? { ok: false, error: sequenceError } : { ok: true, messages };
+}
+__name(parsePriorMessages, "parsePriorMessages");
+
+// src/commands/stdin.ts
+var FIRST_BYTE_DEADLINE_MS = 250;
+async function readStdin(opts = {}) {
+  const input = process.stdin;
+  if (input.isTTY) return "";
+  const chunks = [];
+  const collect = /* @__PURE__ */ __name(async () => {
+    for await (const chunk of input) chunks.push(chunk);
+  }, "collect");
+  if (!opts.deadline) {
+    await collect();
+    return Buffer.concat(chunks).toString("utf8");
+  }
+  let timer;
+  let settleFirstByte;
+  const firstByte = new Promise((resolve2) => {
+    settleFirstByte = resolve2;
+    timer = setTimeout(() => setImmediate(resolve2), FIRST_BYTE_DEADLINE_MS);
+    input.once("readable", settleFirstByte);
+    input.once("end", settleFirstByte);
+  });
+  try {
+    await firstByte;
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (settleFirstByte) {
+      input.removeListener("readable", settleFirstByte);
+      input.removeListener("end", settleFirstByte);
+    }
+  }
+  if (input.readableEnded || input.readableLength > 0) await collect();
+  return Buffer.concat(chunks).toString("utf8");
+}
+__name(readStdin, "readStdin");
+
+// src/commands/exec-json.ts
+var EXIT_TURN_IN_PROGRESS = 75;
+function defaultPrefs(detected) {
+  const first = detected[0];
+  return first ? {
+    version: 3,
+    providers: [{ id: first.entry.id }],
+    subagents: { active: [] }
+  } : null;
+}
+__name(defaultPrefs, "defaultPrefs");
+async function execJson({ ctx: bootstrapCtx }, termination, flags, structuredOutput) {
+  let ctx = bootstrapCtx;
+  const write = /* @__PURE__ */ __name((o) => {
+    process.stdout.write(`${JSON.stringify(o)}
+`);
+  }, "write");
+  const fail = /* @__PURE__ */ __name((message) => {
+    write({ kind: "error", message });
+    write({ kind: "done" });
+    return EXIT_OK;
+  }, "fail");
+  const refuse = /* @__PURE__ */ __name((message) => {
+    write({ kind: "error", message });
+    write({ kind: "done" });
+    return EXIT_FAIL;
+  }, "refuse");
+  const limitsFromFlags = {
+    ...flags.maxIterations !== null ? { maxIterations: flags.maxIterations } : {},
+    ...flags.tokenBudget !== null ? { tokenBudget: flags.tokenBudget } : {}
+  };
+  if (flags.unknown.length > 0) return fail(unknownOptionMessage(flags.unknown));
+  if (structuredOutput && "error" in structuredOutput) return fail(structuredOutput.error);
+  if (flags.continueLast || flags.resume !== null) {
+    return fail(
+      "exec --json does not take --continue or --resume; they belong to the default mode. Bind history with --session <id>, which keys a persisted conversation in this folder."
+    );
+  }
+  if (flags.waitForProviderMs !== null) {
+    return fail(
+      "exec --json does not take --wait-for-provider; it belongs to the default mode. A host reads the paused event and resumes when it chooses."
+    );
+  }
+  const sessionKey = flags.session;
+  const prompt = flags.rest.join(" ").trim();
+  if (!prompt) return fail("no prompt \u2014 pass it as an argument");
+  const resolved = resolveWorkingDirectory(flags.cwd);
+  if ("error" in resolved) return fail(resolved.error);
+  const requestedCwd = resolved.cwd;
+  const trust = decideHeadlessTrust({
+    cwd: requestedCwd,
+    trustFlag: flags.trust
+  });
+  if (!trust.allowed) {
+    write({ kind: "error", message: trust.message ?? "folder not trusted" });
+    write({ kind: "done" });
+    return EXIT_UNTRUSTED;
+  }
+  const cwd = trust.cwd;
+  ctx = resolveTrustedProjectContext(bootstrapCtx, cwd);
+  const expansion = expandHeadlessCommand(prompt, {
+    cwd,
+    builtins: hostCommandNames()
+  });
+  if (expansion.kind === "refused") {
+    return expansion.fixable ? fail(expansion.reason) : refuse(expansion.reason);
+  }
+  const finalPrompt = expansion.kind === "expanded" ? expansion.prompt : prompt;
+  let cli;
+  let conversationId = null;
+  let prior = [];
+  if (!sessionKey) {
+    const parsed = parsePriorMessages(await readStdin({ deadline: true }));
+    if (!parsed.ok) return fail(`invalid stdin history: ${parsed.error}`);
+    prior = [...parsed.messages];
+  }
+  try {
+    cli = await openSessions(cwd);
+    if (sessionKey) {
+      conversationId = await resolveConversation(cli, sessionKey);
+      prior = await loadConversation(cli, conversationId);
+    }
+  } catch (err) {
+    if (sessionKey) {
+      return refuse(
+        `could not open conversation "${sessionKey}": ${err instanceof Error ? err.message : String(err)}. Nothing ran, because continuing the wrong history is worse than not continuing. Drop --session to run this turn stateless.`
+      );
+    }
+    return refuse(
+      `could not open workspace state: ${err instanceof Error ? err.message : String(err)}. Nothing ran, because generated state could not be bound to this working directory.`
+    );
+  }
+  const logging = contextLogging(ctx);
+  installCliLogging(jsonLinesSink(process.stderr), logging.level);
+  const { probeAgentSession, createAgentSession } = await import("./agent-UEK2U3RE.js");
+  const probe = await probeAgentSession();
+  let prefs = probe.preferences ?? defaultPrefs(probe.detected);
+  if (!prefs) {
+    return refuse(
+      "no LLM provider available \u2014 set a credential (e.g. ANTHROPIC_API_KEY) or run `namzu` to pick one"
+    );
+  }
+  prefs = applyProviderFlags(prefs, flags);
+  const modeResult = resolvePermissionMode({
+    flag: flags.permissionMode,
+    skipPermissions: flags.skipPermissions,
+    interactive: false
+  });
+  if ("error" in modeResult) return fail(modeResult.error);
+  warnLegacyMcpPermissionNames(ctx.config.permissions);
+  const permissions = compilePermissions(ctx.config.permissions, ctx.config.permissionChecks);
+  for (const d of permissions.diagnostics) {
+    const where = d.pattern ? `permissions.${d.tool}."${d.pattern}"` : `permissions.${d.tool}`;
+    write({ kind: "error", message: `${where}: ${d.message}` });
+  }
+  const gate = buildGate(flags, cwd);
+  const session = await createAgentSession(prefs, probe.detected, {
+    cwd,
+    ...structuredOutput ? { structuredOutput } : {},
+    scope: {
+      sessionId: conversationId ?? generateSessionId(),
+      topicId: cli.topicId,
+      projectId: cli.projectId,
+      tenantId: cli.tenantId
+    },
+    stateRoot: cli.root,
+    // A keyed conversation appends to its log; a stateless one runs in an
+    // in-memory log, so nothing is written for it.
+    ...conversationId ? { conversationSessions: cli } : { ephemeral: true },
+    rules: permissions.rules,
+    // The operator's --gate commands, as a standing condition on the
+    // answer. Spread rather than passed as undefined so a turn without
+    // gates is byte-identical to the one that shipped before them.
+    ...gate ?? {},
+    permissionMode: modeResult.mode,
+    ...ctx.config.mcpServers ? { mcpServers: ctx.config.mcpServers } : {},
+    ...ctx.config.plugins ? { plugins: ctx.config.plugins } : {},
+    ...ctx.config.skills ? { skills: ctx.config.skills } : {},
+    ...ctx.config.web ? { web: ctx.config.web } : {},
+    ...ctx.config.hooks ? { hooks: ctx.config.hooks } : {},
+    ...ctx.config.compaction ? { compaction: ctx.config.compaction } : {},
+    ...ctx.config.memory ? { memory: ctx.config.memory } : {},
+    ...Object.keys({ ...ctx.config.limits, ...limitsFromFlags }).length > 0 ? { limits: { ...ctx.config.limits, ...limitsFromFlags } } : {},
+    ...ctx.config.sandbox ? { sandbox: ctx.config.sandbox } : {},
+    // `!== undefined`, not truthiness: an empty list is the operator
+    // turning the default screen OFF, and a falsy check would drop it.
+    ...ctx.config.toolResultScreens !== void 0 ? { toolResultScreens: ctx.config.toolResultScreens } : {}
+  });
+  if (!session.hasProvider) {
+    await session.close();
+    const message = session.errorHint ?? "agent is not ready";
+    return session.errorKind === "invocation" ? fail(message) : refuse(message);
+  }
+  if (session.mcpFailed.length > 0) {
+    const said = session.mcpFailed.map((f) => `tool server "${f.name}" is not available: ${f.reason}`).join("; ");
+    await session.close();
+    return refuse(said);
+  }
+  for (const notice of session.configNotices) {
+    write({ kind: "notice", message: notice });
+  }
+  const reportedMcpDiscoveries = /* @__PURE__ */ new Set();
+  const reportMcpDiscoveries = /* @__PURE__ */ __name(() => {
+    for (const server of session.mcpStatus?.().connected ?? session.mcpConnected) {
+      const notices = [
+        ...server.drift?.added.map((name) => `tool added: ${name}`) ?? [],
+        ...server.drift?.removed.map((name) => `tool removed: ${name}`) ?? [],
+        ...server.drift?.changed.map((name) => `tool changed; earlier definition held: ${name}`) ?? [],
+        ...server.refused?.map(
+          (item) => `${item.kind} name refused by policy: ${item.name} (${item.reason})`
+        ) ?? []
+      ];
+      for (const detail of notices) {
+        const message = `tool server "${server.name}": ${detail}`;
+        if (reportedMcpDiscoveries.has(message)) continue;
+        reportedMcpDiscoveries.add(message);
+        write({ kind: "notice", message });
+      }
+    }
+  }, "reportMcpDiscoveries");
+  reportMcpDiscoveries();
+  const extraSystem = await loadSkillsContext(cwd, flags.skills, ctx.config.skills);
+  const userMessage = {
+    role: "user",
+    content: finalPrompt,
+    timestamp: Date.now()
+  };
+  const messages = [...prior, userMessage];
+  let terminalEvent;
+  let budget;
+  let busy;
+  const turnAbort = new AbortController();
+  let stopped = false;
+  let settled;
+  let ended = false;
+  const inConversation = conversationId ? ` in conversation ${conversationId}` : "";
+  termination.onTerminate(async (signal) => {
+    stopped = true;
+    if (!ended) {
+      ended = true;
+      try {
+        write({
+          kind: "error",
+          code: "terminated",
+          message: settled ? `stopped by ${signal} ${settled.state}` : `stopped by ${signal}; the turn was left interrupted${inConversation}. Close it with /abandon in the TUI, or continue it with /resume or \`namzu drain\`.`
+        });
+        write(
+          settled?.last ?? {
+            kind: "done",
+            ...conversationId ? { sessionId: conversationId } : {}
+          }
+        );
+      } catch {
+      }
+    }
+    turnAbort.abort(new TurnCancelled("user"));
+    await session.close();
+    closeSessions(cli);
+  });
+  let paused;
+  try {
+    for await (const event of session.send(messages, {
+      signal: turnAbort.signal,
+      ...extraSystem ? { extraSystem } : {},
+      ...flags.effort !== null ? { effort: flags.effort } : {}
+    })) {
+      if (stopped) continue;
+      if ("budget" in event && event.budget) budget = event.budget;
+      if (event.kind === "paused") paused = event;
+      if (event.kind === "error" && event.turnInProgress) {
+        busy = event.turnInProgress;
+        write({ ...event, code: "turn_in_progress" });
+      } else if (event.kind === "done") terminalEvent = event;
+      else write(event);
+    }
+  } catch (err) {
+    if (stopped) return EXIT_OK;
+    reportMcpDiscoveries();
+    const message = err instanceof Error ? err.message : String(err);
+    settled = {
+      last: { kind: "done" },
+      state: `after the turn failed (${message})${inConversation}.`
+    };
+    await session.close();
+    closeSessions(cli);
+    if (stopped) return EXIT_OK;
+    ended = true;
+    return fail(message);
+  }
+  if (stopped) return EXIT_OK;
+  reportMcpDiscoveries();
+  settled = busy ? {
+    // Nothing was begun, so nothing was recorded: the conversation's
+    // active turn is still the one it was. Not now, rather than not ever.
+    last: { kind: "done", sessionId: busy.sessionId },
+    state: `; no turn was started in conversation ${busy.sessionId}.`
+  } : {
+    // The kernel appended this turn to the conversation's log as it ran,
+    // so a later `history --session <key>` and the next turn's context
+    // see it.
+    last: {
+      ...terminalEvent ?? {
+        kind: "done",
+        ...conversationId ? { sessionId: conversationId } : {}
+      },
+      ...budget ? { budget } : {}
+    },
+    state: paused ? `while the turn was paused: it keeps checkpoint ${paused.checkpointId}${inConversation}. Continue it with /resume or \`namzu drain\`, or close it with /abandon in the TUI.` : `after the turn ended; it is recorded${inConversation}, and nothing is left to close.`
+  };
+  await session.close();
+  closeSessions(cli);
+  if (stopped) return EXIT_OK;
+  ended = true;
+  write(settled.last);
+  return busy ? EXIT_TURN_IN_PROGRESS : 0;
+}
+__name(execJson, "execJson");
+
+// src/commands/resume.ts
+async function resolveResume(sessions, request, cwd) {
+  if (!request.continueLast && !request.sessionId) return { kind: "fresh" };
+  if (request.continueLast && request.sessionId) {
+    return {
+      kind: "error",
+      message: "--continue and --resume ask for different conversations: --continue takes the most recent, --resume takes the one you named. Pass one."
+    };
+  }
+  if (!sessions) {
+    return {
+      kind: "error",
+      message: `no conversation store in ${cwd} \u2014 it could not be opened, so there is nothing to resume`
+    };
+  }
+  if (request.continueLast) {
+    let recent;
+    try {
+      recent = await listRecent(sessions, 50);
+    } catch (err) {
+      return {
+        kind: "error",
+        message: `conversations in ${cwd} cannot be resumed: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    const latest = recent[0];
+    if (!latest) {
+      return {
+        kind: "error",
+        message: `no previous conversation in ${cwd} \u2014 run without --continue to start one, or pass --cwd if you meant a different directory`
+      };
+    }
+    return await load(sessions, latest.id, cwd);
+  }
+  const wanted = request.sessionId;
+  return await load(sessions, wanted, cwd);
+}
+__name(resolveResume, "resolveResume");
+async function load(sessions, sessionId, cwd) {
+  let messages;
+  try {
+    messages = await loadResumableConversation(sessions, sessionId);
+  } catch (err) {
+    return {
+      kind: "error",
+      message: `conversation "${sessionId}" could not be resumed in ${cwd}: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  if (messages.length === 0) {
+    return {
+      kind: "error",
+      message: `conversation "${sessionId}" has no messages to resume \u2014 its transcript is empty`
+    };
+  }
+  return { kind: "resumed", sessionId, messages };
+}
+__name(load, "load");
+
+// src/commands/exec.ts
+function composePrompt(fromArgs, piped) {
+  const question = fromArgs.trim();
+  const material = piped.trim();
+  if (!question) return material;
+  if (!material) return question;
+  return `${question}
+
+<stdin>
+${material}
+</stdin>`;
+}
+__name(composePrompt, "composePrompt");
+function defaultPrefs2(detected) {
+  const first = detected[0];
+  return first ? {
+    version: 3,
+    providers: [{ id: first.entry.id }],
+    subagents: { active: [] }
+  } : null;
+}
+__name(defaultPrefs2, "defaultPrefs");
+function stoppedBy(signal, sessionId, phase, paused) {
+  switch (phase) {
+    case "running":
+      return `stopped by ${signal}: the turn in conversation ${sessionId} was left interrupted \u2014 close it with /abandon in the TUI, or continue it with /resume or \`namzu drain\``;
+    case "paused":
+      return `stopped by ${signal} while the turn was paused: it keeps checkpoint ${paused?.checkpointId ?? "(unknown)"} in conversation ${sessionId} \u2014 continue it with /resume or \`namzu drain\`, or close it with /abandon in the TUI`;
+    case "ended":
+      return `stopped by ${signal} after the turn ended; it is recorded in conversation ${sessionId}, and nothing is left to close`;
+    case "not-started":
+      return `stopped by ${signal}; no turn was started in conversation ${sessionId}`;
+  }
+}
+__name(stoppedBy, "stoppedBy");
+function loadExecOutputSchema(path) {
+  if (path === null) return void 0;
+  const absolute = resolve(process.cwd(), path);
+  try {
+    return loadOutputSchema(absolute);
+  } catch (error) {
+    return {
+      error: `--output-schema ${absolute}: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+__name(loadExecOutputSchema, "loadExecOutputSchema");
+async function execPrint({ ctx: bootstrapCtx }, termination, flags, structuredOutput) {
+  let ctx = bootstrapCtx;
+  const limitsFromFlags = {
+    ...flags.maxIterations !== null ? { maxIterations: flags.maxIterations } : {},
+    ...flags.tokenBudget !== null ? { tokenBudget: flags.tokenBudget } : {}
+  };
+  if (flags.unknown.length > 0) {
+    ctx.formatter.error({ message: unknownOptionMessage(flags.unknown) });
+    return EXIT_USAGE;
+  }
+  if (structuredOutput && "error" in structuredOutput) {
+    ctx.formatter.error({ message: structuredOutput.error });
+    return EXIT_USAGE;
+  }
+  if (flags.session !== null) {
+    ctx.formatter.error({
+      message: "--session binds a host conversation for `exec --json`; this mode resumes with --continue or --resume <id>"
+    });
+    return EXIT_USAGE;
+  }
+  const fromArgs = flags.rest.join(" ").trim() === "-" ? "" : flags.rest.join(" ").trim();
+  const pipedRead = readStdin({ deadline: Boolean(fromArgs) });
+  pipedRead.catch(() => {
+  });
+  const pipedAfterStartup = fromArgs !== "" && !fromArgs.startsWith("/");
+  const piped = pipedAfterStartup ? "" : await pipedRead;
+  const prompt = composePrompt(fromArgs, piped);
+  if (!prompt) {
+    ctx.formatter.error({
+      message: "no prompt \u2014 pass it as an argument or pipe it via stdin"
+    });
+    return 2;
+  }
+  const resolved = resolveWorkingDirectory(flags.cwd);
+  if ("error" in resolved) {
+    ctx.formatter.error({ message: resolved.error });
+    return EXIT_USAGE;
+  }
+  const trust = decideHeadlessTrust({
+    cwd: resolved.cwd,
+    trustFlag: flags.trust
+  });
+  if (!trust.allowed) {
+    ctx.formatter.error({ message: trust.message ?? "folder not trusted" });
+    return EXIT_UNTRUSTED;
+  }
+  const cwd = trust.cwd;
+  ctx = resolveTrustedProjectContext(bootstrapCtx, cwd);
+  const expansion = expandHeadlessCommand(prompt, {
+    cwd,
+    builtins: hostCommandNames()
+  });
+  if (expansion.kind === "refused") {
+    ctx.formatter.error({ message: expansion.reason });
+    return EXIT_USAGE;
+  }
+  const promptUntilPiped = expansion.kind === "expanded" ? expansion.prompt : prompt;
+  const logging = contextLogging(ctx);
+  installCliLogging(createStderrSink(logging.format), logging.level);
+  const { probeAgentSession, createAgentSession } = await import("./agent-UEK2U3RE.js");
+  const probe = await probeAgentSession();
+  let prefs = probe.preferences ?? defaultPrefs2(probe.detected);
+  if (!prefs) {
+    ctx.formatter.error({
+      message: "no LLM provider available \u2014 set a credential (e.g. ANTHROPIC_API_KEY) or run `namzu` to pick one"
+    });
+    return 1;
+  }
+  prefs = applyProviderFlags(prefs, flags);
+  const modeResult = resolvePermissionMode({
+    flag: flags.permissionMode,
+    skipPermissions: flags.skipPermissions,
+    // A headless turn has nobody to ask, so `prompt` here would silently
+    // become `auto`. Resolving it as `auto` says so instead.
+    interactive: false
+  });
+  if ("error" in modeResult) {
+    ctx.formatter.error({ message: modeResult.error });
+    return EXIT_USAGE;
+  }
+  warnLegacyMcpPermissionNames(ctx.config.permissions);
+  const permissions = compilePermissions(ctx.config.permissions, ctx.config.permissionChecks);
+  for (const d of permissions.diagnostics) {
+    const where = d.pattern ? `permissions.${d.tool}."${d.pattern}"` : `permissions.${d.tool}`;
+    ctx.formatter.error({ message: `${where}: ${d.message}` });
+  }
+  const gate = buildGate(flags, cwd);
+  let sessionExport;
+  if (ctx.config.telemetry?.sessionExport) {
+    try {
+      sessionExport = await attachSessionExport({
+        config: ctx.config.telemetry.sessionExport
+      });
+      cliLogger().info(sessionExport.disclosure, {
+        [EVENT_NAME_ATTRIBUTE]: BOOT_EVENT_NAMES.TELEMETRY_STATUS,
+        "namzu.telemetry.session_export": true
+      });
+    } catch (err) {
+      ctx.formatter.error({
+        message: err instanceof Error ? err.message : String(err)
+      });
+      return 1;
+    }
+  }
+  let sessions;
+  try {
+    sessions = await openSessions(cwd);
+  } catch (error) {
+    await sessionExport?.shutdown();
+    ctx.formatter.error({
+      message: `workspace state is unavailable: ${error instanceof Error ? error.message : String(error)}`
+    });
+    return 1;
+  }
+  const resume = await resolveResume(
+    sessions,
+    { continueLast: flags.continueLast, sessionId: flags.resume },
+    cwd
+  );
+  if (resume.kind === "error") {
+    ctx.formatter.error({ message: resume.message });
+    await sessionExport?.shutdown();
+    return EXIT_USAGE;
+  }
+  const prior = resume.kind === "resumed" ? resume.messages : [];
+  let sessionId;
+  try {
+    sessionId = resume.kind === "resumed" ? asSessionId(resume.sessionId) : await startConversation(sessions);
+  } catch (error) {
+    closeSessions(sessions);
+    await sessionExport?.shutdown();
+    ctx.formatter.error({
+      message: `could not start a conversation: ${error instanceof Error ? error.message : String(error)}`
+    });
+    return 1;
+  }
+  const session = await createAgentSession(prefs, probe.detected, {
+    cwd,
+    ...structuredOutput ? { structuredOutput } : {},
+    scope: {
+      sessionId,
+      topicId: sessions.topicId,
+      projectId: sessions.projectId,
+      tenantId: sessions.tenantId
+    },
+    stateRoot: sessions.root,
+    conversationSessions: sessions,
+    rules: permissions.rules,
+    ...sessionExport ? { onSessionEvent: sessionExport.listener } : {},
+    // The operator's --gate commands, as a standing condition on the
+    // answer. Spread rather than passed as undefined so a turn without
+    // gates is byte-identical to the one that shipped before them.
+    ...gate ?? {},
+    permissionMode: modeResult.mode,
+    // Run from the user's own terminal, so a page can be opened on their
+    // desktop. Never `exec --json`, `drain` or a scheduled run.
+    openUrl: true,
+    ...ctx.config.mcpServers ? { mcpServers: ctx.config.mcpServers } : {},
+    ...ctx.config.plugins ? { plugins: ctx.config.plugins } : {},
+    ...ctx.config.skills ? { skills: ctx.config.skills } : {},
+    ...ctx.config.web ? { web: ctx.config.web } : {},
+    ...ctx.config.hooks ? { hooks: ctx.config.hooks } : {},
+    ...ctx.config.compaction ? { compaction: ctx.config.compaction } : {},
+    ...ctx.config.memory ? { memory: ctx.config.memory } : {},
+    ...Object.keys({ ...ctx.config.limits, ...limitsFromFlags }).length > 0 ? { limits: { ...ctx.config.limits, ...limitsFromFlags } } : {},
+    ...ctx.config.sandbox ? { sandbox: ctx.config.sandbox } : {},
+    // `!== undefined`, not truthiness: an empty list is the operator
+    // turning the default screen OFF, and a falsy check would drop it.
+    ...ctx.config.toolResultScreens !== void 0 ? { toolResultScreens: ctx.config.toolResultScreens } : {}
+  });
+  if (!session.hasProvider) {
+    await session.close();
+    closeSessions(sessions);
+    await sessionExport?.shutdown();
+    ctx.formatter.error({
+      message: session.errorHint ?? "agent is not ready"
+    });
+    return 1;
+  }
+  if (session.mcpFailed.length > 0) {
+    for (const f of session.mcpFailed) {
+      ctx.formatter.error({
+        message: `tool server "${f.name}" is not available: ${f.reason}`
+      });
+    }
+    await session.close();
+    closeSessions(sessions);
+    await sessionExport?.shutdown();
+    return 1;
+  }
+  for (const notice of session.configNotices) {
+    ctx.formatter.info(notice);
+  }
+  for (const s of session.mcpConnected) {
+    ctx.formatter.info(`tool server ${s.name} \xB7 ${s.toolCount} tools`);
+  }
+  ctx.formatter.info(
+    `namzu \xB7 ${session.providerSummary}${session.modelSummary ? ` \xB7 ${session.modelSummary}` : ""}`
+  );
+  if (session.instructionFiles.length > 0) {
+    ctx.formatter.info(
+      `project instructions: ${session.instructionFiles.map((p) => relative(cwd, p) || p).join(", ")}`
+    );
+  }
+  for (const skip of session.skippedInstructionFiles) {
+    ctx.formatter.error({
+      message: `skipped ${relative(cwd, skip.path) || skip.path}: ${skip.reason}`
+    });
+  }
+  const extraSystem = await loadSkillsContext(cwd, flags.skills, ctx.config.skills);
+  if (resume.kind === "resumed") {
+    ctx.formatter.info(`resuming ${resume.sessionId} \xB7 ${prior.length} messages`);
+  }
+  let text = "";
+  const measured = {};
+  const jsonResult = /* @__PURE__ */ __name((value) => ({
+    text: value,
+    ...measured.usage ? {
+      usage: {
+        totalTokens: measured.usage.totalTokens,
+        cost: measured.usage.cost
+      }
+    } : {},
+    ...measured.budget ? { budget: measured.budget } : {}
+  }), "jsonResult");
+  let stopReason;
+  const stop = {
+    failed: null,
+    paused: null,
+    busy: false
+  };
+  const turnAbort = new AbortController();
+  let stopped = false;
+  let phase = "running";
+  const afterPhase = /* @__PURE__ */ __name(() => {
+    phase = stop.busy ? "not-started" : stop.paused ? "paused" : "ended";
+  }, "afterPhase");
+  termination.onTerminate(async (signal) => {
+    stopped = true;
+    ctx.formatter.error({ message: stoppedBy(signal, sessionId, phase, stop.paused) });
+    turnAbort.abort(new TurnCancelled("user"));
+    await session.close();
+    closeSessions(sessions);
+    await sessionExport?.shutdown();
+  });
+  const consume = /* @__PURE__ */ __name(async (stream) => {
+    stop.failed = null;
+    stop.paused = null;
+    for await (const event of stream) {
+      if (event.kind === "delta") text += event.text;
+      else if (event.kind === "tool-start")
+        ctx.formatter.info(`Tool: ${event.toolName} ${event.summary}`);
+      else if (event.kind === "context") ctx.formatter.info(event.text);
+      else if (event.kind === "error" || event.kind === "paused") {
+        if (event.budget) measured.budget = event.budget;
+        stop.failed = describeTurnInterruption(event);
+        if (event.kind === "error" && event.turnInProgress) {
+          stop.busy = true;
+          stop.failed = `conversation ${event.turnInProgress.sessionId} already has a ${event.turnInProgress.state} turn ${event.turnInProgress.activeTurnId}; nothing was started. Finish it with \`namzu drain\`, or abandon it with /abandon in the TUI.`;
+        }
+        if (event.kind === "paused") stop.paused = event;
+      } else if (event.kind === "usage") {
+        measured.usage = event;
+        if (event.budget) measured.budget = event.budget;
+      } else if (event.kind === "done") {
+        if (event.text !== void 0) text = event.text;
+        stopReason = event.stopReason;
+        if (event.budget) measured.budget = event.budget;
+      }
+    }
+  }, "consume");
+  const finalPrompt = pipedAfterStartup ? composePrompt(fromArgs, await pipedRead) : promptUntilPiped;
+  await consume(
+    session.send([...prior, { role: "user", content: finalPrompt, timestamp: Date.now() }], {
+      signal: turnAbort.signal,
+      ...extraSystem ? { extraSystem } : {},
+      ...flags.effort !== null ? { effort: flags.effort } : {}
+    })
+  );
+  afterPhase();
+  const waitBudgetMs = flags.waitForProviderMs ?? ctx.config.limits?.waitForProviderMs ?? 0;
+  let waits = 0;
+  let waitedMs = 0;
+  while (!stopped && stop.paused && waitBudgetMs > 0 && (stop.paused.providerError || stop.paused.failure)) {
+    const paused2 = stop.paused;
+    const asked = retryAfterMs(paused2);
+    const decision = pauseWait({
+      waited: waits,
+      ...asked !== void 0 ? { retryAfterMs: asked } : {},
+      waitedMs,
+      budgetMs: waitBudgetMs
+    });
+    if (decision.kind === "stop") {
+      stop.failed = `${stop.failed}
+Not resumed: ${decision.reason}.`;
+      break;
+    }
+    waits += 1;
+    ctx.formatter.info(
+      `provider paused the turn: waiting ${duration(decision.delayMs)}, then resuming from ${paused2.checkpointId} (wait ${waits}, ${duration(waitedMs)} of ${duration(waitBudgetMs)} spent)`
+    );
+    await new Promise((resolve2) => setTimeout(resolve2, decision.delayMs));
+    if (stopped) break;
+    waitedMs += decision.delayMs;
+    phase = "running";
+    await consume(
+      session.resumePaused({
+        turnId: paused2.turnId,
+        checkpointId: paused2.checkpointId,
+        signal: turnAbort.signal
+      })
+    );
+    afterPhase();
+  }
+  if (stopped) return 1;
+  const failed = stop.failed;
+  const paused = stop.paused !== null || stop.busy;
+  await session.close();
+  closeSessions(sessions);
+  await sessionExport?.shutdown();
+  if (measured.budget) {
+    ctx.formatter.info(
+      `Tokens: ${measured.budget.ownTokens} own \xB7 ${measured.budget.treeTokens} including descendants`
+    );
+  }
+  if (failed) {
+    const partial = text.trim();
+    if (partial) {
+      ctx.formatter.print(ctx.formatter.name === "json" ? jsonResult(partial) : partial);
+    }
+    ctx.formatter.error({
+      message: `${failed}${partial ? " \u2014 the output above is partial" : ""}`
+    });
+    return paused ? 75 : 1;
+  }
+  ctx.formatter.print(ctx.formatter.name === "json" ? jsonResult(text.trim()) : text.trim());
+  if (stopReason && stopReason !== "end_turn") {
+    ctx.formatter.error({
+      message: `turn did not finish normally: ${stopReason}${text.trim() ? " \u2014 the output above is partial" : ""}`
+    });
+    return 1;
+  }
+  return 0;
+}
+__name(execPrint, "execPrint");
+var execCommand = {
+  name: "exec",
+  aliases: ["e"],
+  description: "Run a single prompt headlessly: print the reply, or stream events with --json",
+  passThrough: true,
+  help: [
+    "Usage: namzu exec [options] <prompt...>",
+    '       echo "<prompt>" | namzu exec',
+    '       cat file.txt | namzu exec "summarise this"',
+    "       namzu exec --json [--session <id>] <prompt...>",
+    "",
+    "Run a single prompt headlessly. Everything that is not an option is the",
+    "prompt. `namzu e` is the same command.",
+    "",
+    "By default the reply is printed on stdout and status lines go to stderr.",
+    "Piped input is used too, not discarded: with no prompt argument it IS",
+    "the prompt, and alongside one it is appended as material the question",
+    "is about. `namzu exec -` reads the prompt from stdin explicitly.",
+    "",
+    "Options:",
+    "  --json                Stream one JSON event per line instead of the reply",
+    "  --output-schema <f>   Bind the final answer to the JSON Schema in file f,",
+    "                        using the provider\u2019s native structured output",
+    "  --cwd <path>          Directory the agent works in (default: this one)",
+    "  --provider <id>       Provider to answer with",
+    "  --model <id>          Model to answer with",
+    "  --skills <a,b,c>      Load these skills as context for the turn",
+    "  --continue, -c        Resume the most recent conversation here",
+    "  --resume <id>         Resume that conversation, and no other",
+    "  --session <id>        With --json: bind the turn to the host conversation",
+    "                        keyed by this id",
+    "  --gate <command>      Verify proposed answers with this command; repeatable",
+    "  --gate-retries <n>    Fix attempts a failing gate allows (default 3)",
+    "  --max-iterations <n>  Main-loop iteration limit (default 50; 0 unlimited)",
+    "  --token-budget <n>    Tree token limit (default unlimited; 0 removes a configured cap)",
+    "  --effort <level>      Explicit reasoning effort (supported levels depend on the model)",
+    "  --wait-for-provider <d>  Wait out provider pauses (a rate limit, an outage)",
+    "                        for up to this long in total \u2014 90s, 30m, 2h \u2014 resuming",
+    "                        from the checkpoint each time (default: none; exit 75)",
+    "  --permission-mode <m> prompt | accept-edits | auto | strict | plan \u2014",
+    "                        what happens to a call no [permissions] rule",
+    "                        decided (default: auto)",
+    "  --trust               Accept this folder for THIS turn",
+    "  --                    End of options; the rest is the prompt verbatim",
+    "",
+    "A folder has to be trusted before namzu will work in it, because namzu",
+    "reads its files, runs commands in it and executes its code. Run `namzu`",
+    "here once and accept the prompt to trust it permanently, or pass --trust",
+    "to accept it for one turn. --trust does not remember; that is the point.",
+    "",
+    "--yolo does NOT imply --trust: one is about which tools may run inside a",
+    "folder, the other about the folder.",
+    "",
+    "By default tools run without asking, because there is nobody to ask, and",
+    "the safety gate still refuses catastrophic commands. Use --permission-mode",
+    "strict for an unattended turn that must refuse anything no rule allowed.",
+    "",
+    "A mode only decides calls no rule decided: it can never reopen a deny.",
+    "",
+    "--gate checks proposed answers with operator-supplied commands. Every",
+    "command must complete successfully; a failure returns diagnostics to the",
+    "model for correction. Repeat the flag to check several commands in order.",
+    "Budget exhaustion or cancellation may stop a turn before verification.",
+    "",
+    "A failed gate may skip a retry when its Git change detector is unchanged.",
+    "The attempt still counts. Exhausted review attempts stop the turn with",
+    "answer_rejected and a non-zero exit.",
+    "",
+    "The working directory\u2019s AGENTS.md files \u2014 that directory and every one up",
+    "to the repository root \u2014 are loaded as standing instructions for the turn,",
+    "and the ones that were loaded are named on stderr.",
+    "",
+    "--continue and --resume refuse when the conversation cannot be reopened,",
+    "and say why. Neither ever falls back to starting a new one: leave both",
+    "out if that is what you want.",
+    "",
+    "Needs a provider. Set a credential in the environment, or run namzu",
+    "once to pick one interactively.",
+    "",
+    "A turn the provider pauses keeps a checkpoint. Without --wait-for-provider",
+    "it exits 75 at once and a wrapper decides when to try again; with it, the",
+    "turn waits the provider\u2019s own delay when it named one (otherwise a minute,",
+    "doubling, at most fifteen) and resumes from the checkpoint in this process,",
+    "until the budget is spent. The `limits.waitForProviderMs` config key sets",
+    "the same budget for every turn in the folder.",
+    "",
+    "Exit codes: 0 on a reply, 1 on a failed or unfinished turn, 2 when no",
+    "prompt was supplied, 64 when an argument is wrong, 75 when the provider",
+    "paused the turn (a rate limit or an outage) and a checkpoint was kept \u2014",
+    "wait, then try again \u2014 or when the conversation already has an active",
+    "turn (a paused one: finish it with `namzu drain`, or abandon it in the",
+    "TUI with /abandon), and 77 when the folder has not been trusted and",
+    "nothing was done.",
+    "",
+    "With --json:",
+    "",
+    "Each line is one event as the turn unfolds \u2014 text deltas, tool starts and",
+    "ends, usage, then a terminal done event. done.text is the settled answer;",
+    "earlier deltas may include progress or answers later rejected by",
+    "verification. History is bound with --session <id>; --continue, --resume",
+    "and --wait-for-provider are refused. Without --session, optional stdin",
+    "must be one complete JSON Message[]; invalid or provider-incomplete tool",
+    "history is refused before a turn.",
+    "",
+    "Every failure is an event on stdout. The exit code says whether YOU can",
+    "do anything about it: 0 when changing what you send would reach the turn",
+    "(a wrong option, no prompt, a bad --cwd) and when a turn started and",
+    "failed; 1 when it would not (no provider, a tool server that is not",
+    "there, a conversation that cannot be opened); 75 when the --session",
+    "conversation already has an active turn (a paused one: finish it with",
+    '`namzu drain`), and the error event carries code "turn_in_progress"; 77',
+    "when the folder has not been trusted, which only a person can change."
+  ].join("\n"),
+  handler: withTerminationHandling(async (args, termination) => {
+    const flags = parseExecFlags(args.rawArgs);
+    const structuredOutput = loadExecOutputSchema(flags.outputSchema);
+    return flags.json ? execJson(args, termination, flags, structuredOutput) : execPrint(args, termination, flags, structuredOutput);
+  })
+};
+export {
+  composePrompt,
+  execCommand
+};
+//# sourceMappingURL=exec-COV235L5.js.map