@namzu/cli 34.1.1 → 36.0.0

package/dist/chunks/add-DLS54YKS.js

@@ -0,0 +1,712 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+import {
+  changesBlock,
+  changesSinceConfirmed,
+  confirmationView,
+  describeChanges
+} from "./chunk-EVY4MVRE.js";
+import {
+  visibleScheduleMessage
+} from "./chunk-NADQQMMG.js";
+import {
+  askYesNo
+} from "./chunk-GWQEMJFS.js";
+import {
+  JobRequestError,
+  buildJob,
+  confirmJob,
+  editedJob,
+  isPrivacyProtectedFolder,
+  previewLines,
+  scriptShellUnavailableReason,
+  verifyScheduledScript
+} from "./chunk-6ZPODOJN.js";
+import {
+  compileJobPolicy,
+  compileScriptCheckPolicy,
+  isPresetName
+} from "./chunk-MS3IYQ72.js";
+import {
+  appendHistory,
+  readHistory,
+  readState
+} from "./chunk-WT6TFCPV.js";
+import {
+  flag,
+  has,
+  interactive,
+  parseArgs,
+  parseCount,
+  parseMs,
+  pathsFor
+} from "./chunk-BCZR2B3Y.js";
+import "./chunk-WHODOMXA.js";
+import "./chunk-OWXJOD4H.js";
+import {
+  createJob,
+  findJob,
+  sanitizeLine,
+  updateJob
+} from "./chunk-SKKWMMFP.js";
+import "./chunk-OEW7CJKK.js";
+import "./chunk-A22MBIYU.js";
+import {
+  readPermissionLayers
+} from "./chunk-YYQJIECC.js";
+import "./chunk-KONYGNG6.js";
+import "./chunk-NICLKFBG.js";
+import "./chunk-42ZK2AH4.js";
+import "./chunk-US5ZFPAU.js";
+import "./chunk-SB6UD3ED.js";
+import "./chunk-6LLJQ3KY.js";
+import {
+  EXIT_OK,
+  EXIT_USAGE
+} from "./chunk-Y7B67G22.js";
+import "./chunk-NIPHHZ5G.js";
+import "./chunk-6CPT2ZBS.js";
+import "./chunk-AHIDYIRB.js";
+import "./chunk-GIXSS6KW.js";
+import "./chunk-M3IAMIBJ.js";
+import "./chunk-FOFGMP7O.js";
+import {
+  installedCommandShellForDialect
+} from "./chunk-K5HARZ7G.js";
+import {
+  __name
+} from "./chunk-76FLAFCG.js";
+
+// src/schedule/commands/add.ts
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+var ADD_FLAGS = [
+  "home",
+  "prompt",
+  "prompt-file",
+  "when",
+  "folder",
+  "workspace",
+  "permissions",
+  "unmatched",
+  "execution",
+  "tz",
+  "model",
+  "effort",
+  "max-iterations",
+  "token-budget",
+  "timeout",
+  "wait-for-provider",
+  "approval-ttl",
+  "keep-sessions",
+  "pause-after-failures",
+  "add-dir",
+  "paused!",
+  "yes!",
+  "allow-unattended-host!",
+  "notify-finished",
+  "notify-summary!",
+  "browser",
+  "browser-site",
+  "browser-headed!",
+  "no-browser!",
+  "kind",
+  "script",
+  "script-file",
+  "shell",
+  "script-timeout",
+  "script-report",
+  "delivery"
+];
+var RUN_KINDS = ["agent", "script", "script+agent"];
+function isRunKind(value) {
+  return RUN_KINDS.includes(value);
+}
+__name(isRunKind, "isRunKind");
+function scriptBodyOf(args) {
+  const inline = flag(args, "script");
+  const file = flag(args, "script-file");
+  if (inline !== void 0 && file !== void 0) {
+    throw new JobRequestError("pass --script or --script-file, not both");
+  }
+  if (file !== void 0) return readFileSync(resolve(file), "utf8");
+  return inline;
+}
+__name(scriptBodyOf, "scriptBodyOf");
+function browserInput(args, base) {
+  const profile = flag(args, "browser");
+  const written = args.flags.get("browser-site") ?? [];
+  if (has(args, "no-browser")) {
+    if (profile !== void 0 || written.length > 0 || has(args, "browser-headed")) {
+      throw new JobRequestError("--no-browser cannot be combined with other --browser flags");
+    }
+    return void 0;
+  }
+  if (!base && profile === void 0) {
+    if (written.length > 0 || has(args, "browser-headed")) {
+      throw new JobRequestError(
+        "--browser-site and --browser-headed need --browser <profile>: the profile you signed in with `namzu browser login`"
+      );
+    }
+    return void 0;
+  }
+  const sites = { ...base?.sites ?? {} };
+  for (const entry of written) {
+    const at = entry.lastIndexOf("=");
+    const site = at > 0 ? entry.slice(0, at).trim() : "";
+    const level = at > 0 ? entry.slice(at + 1).trim() : "";
+    if (!site || !level) {
+      throw new JobRequestError(
+        `--browser-site ${entry}: write <site>=read, <site>=ask or <site>=act, e.g. https://github.com=read`
+      );
+    }
+    if (level === "none") {
+      if (!base)
+        throw new JobRequestError(
+          `--browser-site ${entry}: none only takes a site off an existing job`
+        );
+      const key = Object.keys(sites).find(
+        (k) => k.toLowerCase() === site.toLowerCase().replace(/\/+$/, "")
+      );
+      if (key === void 0)
+        throw new JobRequestError(`--browser-site ${entry}: the job has no site ${site}`);
+      delete sites[key];
+      continue;
+    }
+    sites[site] = level;
+  }
+  return {
+    profile: profile ?? base?.profile,
+    sites,
+    ...has(args, "browser-headed") || base?.headed ? { headed: true } : {}
+  };
+}
+__name(browserInput, "browserInput");
+function permissionInput(args, baseBrowser) {
+  const value = flag(args, "permissions");
+  const browser = browserInput(args, baseBrowser);
+  if (!value && browser) {
+    const unmatched2 = flag(args, "unmatched");
+    if (unmatched2 !== "park" && unmatched2 !== "deny" && unmatched2 !== "allow") {
+      throw new JobRequestError(
+        "a job with only a browser grant needs --unmatched park|deny|allow (or add --permissions read-only)"
+      );
+    }
+    return {
+      unmatched: unmatched2,
+      browser,
+      ...flag(args, "execution") === "sandbox" ? { execution: "sandbox" } : {}
+    };
+  }
+  if (!value) {
+    throw new JobRequestError(
+      '--permissions is required: read-only, edit-in-folder, or a JSON file with {"rules": {...}, "unmatched": "park"|"deny"|"allow"}'
+    );
+  }
+  let input;
+  if (isPresetName(value)) input = { preset: value };
+  else {
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync(resolve(value), "utf8"));
+    } catch (error) {
+      throw new JobRequestError(
+        `--permissions ${value} is neither a preset (read-only, edit-in-folder) nor a readable JSON file: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    input = {
+      ...isPresetName(parsed.preset) ? { preset: parsed.preset } : {},
+      ...parsed.rules && typeof parsed.rules === "object" ? { rules: parsed.rules } : {},
+      ...parsed.unmatched === "park" || parsed.unmatched === "deny" || parsed.unmatched === "allow" ? { unmatched: parsed.unmatched } : {},
+      ...parsed.execution === "host" || parsed.execution === "sandbox" ? { execution: parsed.execution } : {},
+      ...Array.isArray(parsed.additionalDirectories) ? { additionalDirectories: parsed.additionalDirectories.map(String) } : {},
+      ...parsed.browser && typeof parsed.browser === "object" ? { browser: parsed.browser } : {}
+    };
+  }
+  if (browser) input = { ...input, browser };
+  const unmatched = flag(args, "unmatched");
+  if (unmatched !== void 0) {
+    if (unmatched !== "park" && unmatched !== "deny" && unmatched !== "allow") {
+      throw new JobRequestError("--unmatched is park, deny or allow");
+    }
+    input = { ...input, unmatched };
+  }
+  const execution = flag(args, "execution");
+  if (execution !== void 0) {
+    if (execution !== "host" && execution !== "sandbox")
+      throw new JobRequestError("--execution is host or sandbox");
+    input = { ...input, execution };
+  }
+  const dirs = args.flags.get("add-dir");
+  if (dirs)
+    input = {
+      ...input,
+      additionalDirectories: [
+        ...input.additionalDirectories ?? [],
+        ...dirs.map((d) => resolve(d))
+      ]
+    };
+  return input;
+}
+__name(permissionInput, "permissionInput");
+function promptOf(args) {
+  const inline = flag(args, "prompt");
+  const file = flag(args, "prompt-file");
+  if (inline && file) throw new JobRequestError("pass --prompt or --prompt-file, not both");
+  if (file) return readFileSync(resolve(file), "utf8");
+  if (inline) return inline;
+  throw new JobRequestError("--prompt (or --prompt-file) is required");
+}
+__name(promptOf, "promptOf");
+function requestFrom(args, name, base, waiverRunIds = []) {
+  const notifyFinished = flag(args, "notify-finished");
+  if (notifyFinished !== void 0 && notifyFinished !== "true" && notifyFinished !== "false") {
+    throw new JobRequestError("--notify-finished is true or false");
+  }
+  const budget = {
+    ...parseCount("--max-iterations", flag(args, "max-iterations")) !== void 0 ? {
+      maxIterations: parseCount("--max-iterations", flag(args, "max-iterations"))
+    } : base ? { maxIterations: base.budget.maxIterations } : {},
+    ...parseCount("--token-budget", flag(args, "token-budget")) !== void 0 ? {
+      tokenBudget: parseCount("--token-budget", flag(args, "token-budget"))
+    } : base ? { tokenBudget: base.budget.tokenBudget } : {},
+    ...parseMs("--timeout", flag(args, "timeout")) !== void 0 ? { timeoutMs: parseMs("--timeout", flag(args, "timeout")) } : base ? { timeoutMs: base.budget.timeoutMs } : {},
+    ...parseMs("--wait-for-provider", flag(args, "wait-for-provider")) !== void 0 ? {
+      waitForProviderMs: parseMs(
+        "--wait-for-provider",
+        flag(args, "wait-for-provider")
+      )
+    } : base ? { waitForProviderMs: base.budget.waitForProviderMs } : {}
+  };
+  const approval = parseMs("--approval-ttl", flag(args, "approval-ttl"));
+  const keep = parseCount("--keep-sessions", flag(args, "keep-sessions"));
+  const pauseAfter = parseCount("--pause-after-failures", flag(args, "pause-after-failures"));
+  const model = flag(args, "model");
+  const effort = flag(args, "effort");
+  const tz = flag(args, "tz") ?? (base?.schedule.kind === "cron" ? base.schedule.tz : void 0);
+  const kindFlag = flag(args, "kind");
+  if (kindFlag !== void 0 && !isRunKind(kindFlag)) {
+    throw new JobRequestError(`--kind is ${RUN_KINDS.join(", ")}`);
+  }
+  const runKind = kindFlag ?? base?.runKind ?? "agent";
+  const workspaceFlag = flag(args, "workspace");
+  if (workspaceFlag !== void 0 && workspaceFlag !== "none" && workspaceFlag !== "project")
+    throw new JobRequestError("--workspace is none or project");
+  const workspace = workspaceFlag === "project" ? void 0 : workspaceFlag ?? base?.workspace;
+  const deliveryFlag = flag(args, "delivery");
+  if (deliveryFlag !== void 0 && deliveryFlag !== "none")
+    throw new JobRequestError("--delivery is none (only when editing a source-bound job)");
+  if (deliveryFlag === "none" && !base)
+    throw new JobRequestError("--delivery none needs an existing job");
+  if (workspace === "none" && has(args, "folder"))
+    throw new JobRequestError("--workspace none cannot be combined with --folder");
+  if (workspaceFlag === "project" && base?.workspace === "none" && !has(args, "folder"))
+    throw new JobRequestError("--workspace project needs --folder when changing a no-project job");
+  if (runKind === "script" && (model !== void 0 || effort !== void 0)) {
+    throw new JobRequestError(
+      "a pure script job has no model or effort; remove --model and --effort"
+    );
+  }
+  if (runKind === "script" && (has(args, "prompt") || has(args, "prompt-file")))
+    throw new JobRequestError("a pure script job has no prompt; remove --prompt and --prompt-file");
+  const agentOnlyFlag = [
+    "max-iterations",
+    "token-budget",
+    "timeout",
+    "wait-for-provider",
+    "approval-ttl",
+    "keep-sessions"
+  ].find((name2) => has(args, name2));
+  if (runKind === "script" && agentOnlyFlag) {
+    throw new JobRequestError(
+      `--${agentOnlyFlag} does not apply to a pure script job; use --script-timeout to limit the script itself`
+    );
+  }
+  const shellFlag = flag(args, "shell");
+  if (shellFlag !== void 0 && shellFlag !== "bash" && shellFlag !== "sh") {
+    throw new JobRequestError("--shell is bash or sh");
+  }
+  const scriptGiven = has(args, "script") || has(args, "script-file");
+  const scriptBody = scriptGiven ? scriptBodyOf(args) : base?.script?.body;
+  const shell = shellFlag ?? base?.script?.shell;
+  if (runKind !== "agent" && shell === void 0) {
+    throw new JobRequestError("--shell bash|sh is required for a script or script+agent job");
+  }
+  const scriptTimeoutMs = parseMs("--script-timeout", flag(args, "script-timeout")) ?? base?.script?.timeoutMs;
+  const scriptReportFlag = flag(args, "script-report");
+  if (scriptReportFlag !== void 0 && scriptReportFlag !== "json-v1" && scriptReportFlag !== "none")
+    throw new JobRequestError("--script-report is json-v1 or none");
+  if (scriptReportFlag !== void 0 && runKind !== "script")
+    throw new JobRequestError("--script-report only applies to a pure script job");
+  const scriptReport = runKind === "script" ? scriptReportFlag === "none" ? void 0 : scriptReportFlag ?? base?.script?.report : void 0;
+  const prompt = (() => {
+    if (runKind === "script") return "";
+    if (has(args, "prompt") || has(args, "prompt-file")) return promptOf(args);
+    if (base) return base.prompt;
+    return promptOf(args);
+  })();
+  const chosenPermissions = has(args, "permissions") ? permissionInput(args, base?.permissions.browser) : base ? (() => {
+    const browser = browserInput(args, base.permissions.browser);
+    const unmatched = flag(args, "unmatched");
+    return {
+      rules: base.permissions.rules,
+      unmatched: unmatched === "park" || unmatched === "deny" || unmatched === "allow" ? unmatched : base.permissions.unmatched,
+      execution: base.permissions.execution,
+      ...base.permissions.additionalDirectories ? {
+        additionalDirectories: base.permissions.additionalDirectories
+      } : {},
+      ...browser ? { browser } : {}
+    };
+  })() : permissionInput(args);
+  if (runKind === "script" && chosenPermissions.browser && (base?.runKind !== "script" || has(args, "permissions") || has(args, "browser") || has(args, "browser-site") || has(args, "browser-headed"))) {
+    throw new JobRequestError(
+      "a pure script job cannot use a browser grant; remove --browser flags or the browser field in --permissions"
+    );
+  }
+  return {
+    name,
+    prompt,
+    ...runKind !== "agent" ? {
+      runKind,
+      script: {
+        body: scriptBody ?? "",
+        shell,
+        ...scriptTimeoutMs !== void 0 ? { timeoutMs: scriptTimeoutMs } : {},
+        ...scriptReport ? { report: scriptReport } : {}
+      }
+    } : {},
+    when: flag(args, "when") ?? "",
+    ...!flag(args, "when") && !flag(args, "tz") && base ? { spec: base.schedule } : {},
+    ...workspace === "none" ? { workspace } : { folder: resolve(flag(args, "folder") ?? base?.folder.path ?? process.cwd()) },
+    ...base?.delivery && deliveryFlag !== "none" ? { delivery: base.delivery } : {},
+    ...base?.deliveryWaiverRunIds?.length || waiverRunIds.length ? {
+      deliveryWaiverRunIds: [
+        .../* @__PURE__ */ new Set([...base?.deliveryWaiverRunIds ?? [], ...waiverRunIds])
+      ]
+    } : {},
+    ...tz ? { tz } : {},
+    permissions: chosenPermissions,
+    budget,
+    ...runKind === "script" ? {} : model ? { model } : base?.model ? {
+      model: `${base.model.provider}${base.model.model ? `/${base.model.model}` : ""}`
+    } : {},
+    ...runKind === "script" ? {} : effort ? { effort } : base?.model?.effort ? { effort: base.model.effort } : {},
+    ...has(args, "notify-summary") ? { includeSummary: true } : base ? { includeSummary: base.notify.includeSummary } : {},
+    ...notifyFinished !== void 0 ? { notifyOnFinish: notifyFinished === "true" } : base ? { notifyOnFinish: base.notify.finished } : {},
+    ...keep !== void 0 ? { keepSessions: keep } : base ? { keepSessions: base.retention.keepSessions } : {},
+    ...pauseAfter !== void 0 ? { pauseAfterFailures: pauseAfter } : base ? { pauseAfterFailures: base.failurePolicy.pauseAfterFailures } : {},
+    ...approval !== void 0 ? { approvalTtlMs: approval } : base ? { approvalTtlMs: base.approvalTtlMs } : {},
+    createdBy: base?.createdBy ?? { surface: "cli" },
+    allowUnattendedHost: has(args, "allow-unattended-host")
+  };
+}
+__name(requestFrom, "requestFrom");
+async function confirmOnTerminal(ctx, paths, job, args, verb, changes = []) {
+  const layers = readPermissionLayers({
+    cwd: job.folder.canonical,
+    env: { ...process.env, NAMZU_HOME: paths.home },
+    ...job.workspace === "none" ? { includeProject: false } : {}
+  });
+  const policy = compileJobPolicy(job.permissions, {
+    layers,
+    namzuHome: paths.home,
+    folder: job.folder
+  });
+  if (policy.diagnostics.length > 0) {
+    throw new JobRequestError(`permission rules do not compile: ${policy.diagnostics.join("; ")}`);
+  }
+  if (job.runKind && job.runKind !== "agent" && job.script) {
+    const selectedShell = installedCommandShellForDialect(job.script.shell);
+    if (!selectedShell) throw new JobRequestError(scriptShellUnavailableReason(job.script.shell));
+    const scriptPolicy = compileScriptCheckPolicy(job.permissions, {
+      layers,
+      namzuHome: paths.home,
+      folder: job.folder
+    });
+    const checked = verifyScheduledScript(job.script.body, selectedShell.dialect, scriptPolicy);
+    if (!checked.ok) {
+      throw new JobRequestError(
+        `the ${job.runKind === "script" ? "script" : "wake-gate script"} was refused: ${checked.reason}`
+      );
+    }
+  }
+  const now = /* @__PURE__ */ new Date();
+  ctx.formatter.info(visibleScheduleMessage(previewLines(job, policy, now).join("\n")));
+  const indented = /* @__PURE__ */ __name((text) => text.split("\n").map((l) => `  ${l}`).join("\n"), "indented");
+  if (job.runKind && job.runKind !== "agent" && job.script) {
+    const scriptRules = job.runKind === "script" ? "shell commands are checked against the scheduled-run floor and deny rules; interpreter code (for example, Python) is not parsed and must be reviewed by you" : "the scheduled-run floor and every deny rule apply to the gate, and the permission set governs the agent phase";
+    ctx.formatter.info(
+      visibleScheduleMessage(
+        `${job.runKind === "script" ? "Script" : "Wake-gate script"} (${job.script.shell}, shell checks passed)
+${indented(job.script.body)}
+The stored source runs as entered; ${scriptRules}`
+      )
+    );
+  }
+  if (job.prompt.trim()) {
+    ctx.formatter.info(
+      visibleScheduleMessage(
+        `${job.runKind === "script+agent" ? "Prompt (used only when the wake-gate says wake: true)" : "Prompt"}
+${indented(job.prompt)}`
+      )
+    );
+  }
+  if (changes.length > 0)
+    ctx.formatter.info(visibleScheduleMessage(changesBlock(changes).join("\n")));
+  if (job.workspace !== "none" && process.platform === "darwin" && isPrivacyProtectedFolder(job.folder.canonical)) {
+    ctx.formatter.info(
+      "Warning: this folder is under Documents, Desktop or Downloads; macOS may block the scheduler from reading it until you grant it Files and Folders access."
+    );
+  }
+  if (!interactive()) {
+    if (!has(args, "yes")) {
+      throw new JobRequestError(
+        `no terminal to confirm on; pass --yes to ${verb} the job inert (it waits for confirmation on a terminal or in the TUI)`
+      );
+    }
+    return "cli-noninteractive";
+  }
+  if (has(args, "yes")) return "cli-noninteractive";
+  const question = verb === "create" ? "Create" : verb === "confirm" ? "Confirm" : "Save";
+  return await askYesNo(`${question} this scheduled job?`) ? "cli-tty" : null;
+}
+__name(confirmOnTerminal, "confirmOnTerminal");
+async function addCommand(ctx, argv) {
+  const args = parseArgs(argv, ADD_FLAGS);
+  if (args.unknown.length > 0) {
+    ctx.formatter.error({
+      message: `unknown option: ${args.unknown.join(", ")}`
+    });
+    return EXIT_USAGE;
+  }
+  const name = args.positionals[0];
+  if (!name) {
+    ctx.formatter.error({
+      message: "usage: namzu schedule add <name> --prompt <text> --when <spec> --permissions <preset|file>"
+    });
+    return EXIT_USAGE;
+  }
+  const paths = pathsFor(args);
+  try {
+    if (has(args, "delivery"))
+      throw new JobRequestError("--delivery none only applies to schedule edit");
+    const now = /* @__PURE__ */ new Date();
+    const built = buildJob(requestFrom(args, name), {
+      paths,
+      config: ctx.config,
+      now
+    });
+    const surface = await confirmOnTerminal(ctx, paths, built, args, "create");
+    if (surface === null) {
+      ctx.formatter.info("Not created.");
+      return 1;
+    }
+    const job = createJob(
+      paths,
+      confirmJob(built, surface, now, { paused: has(args, "paused"), paths })
+    );
+    appendHistory(paths, job.id, {
+      v: 1,
+      kind: "job",
+      at: now.toISOString(),
+      action: "created",
+      by: surface
+    });
+    if (job.state === "pending-confirmation") {
+      ctx.formatter.print({
+        text: `Created ${job.name}, held until confirmed: run \`namzu schedule confirm ${job.name}\` on a terminal, or confirm it in the TUI with /schedule.`,
+        id: job.id,
+        name: job.name,
+        state: job.state
+      });
+    } else {
+      ctx.formatter.print({
+        text: `Created ${job.name} (${job.state}). ${job.state === "active" ? "The scheduler runs it on time; check with `namzu schedule status`." : ""}`.trim(),
+        id: job.id,
+        name: job.name,
+        state: job.state
+      });
+    }
+    return EXIT_OK;
+  } catch (error) {
+    ctx.formatter.error({
+      message: visibleScheduleMessage(error instanceof Error ? error.message : String(error))
+    });
+    return error instanceof JobRequestError ? EXIT_USAGE : 1;
+  }
+}
+__name(addCommand, "addCommand");
+function pendingSourceRunIds(paths, jobId) {
+  return (readState(paths, jobId).deliveryPending ?? []).filter((item) => item.delivery).map((item) => item.result.runId);
+}
+__name(pendingSourceRunIds, "pendingSourceRunIds");
+function deliveryWaiverLines(paths, job) {
+  if (job.delivery) return [];
+  const approved = new Set(job.deliveryWaiverRunIds ?? []);
+  const pending = (readState(paths, job.id).deliveryPending ?? []).filter(
+    (item) => item.delivery && approved.has(item.result.runId)
+  );
+  if (pending.length === 0) return [];
+  return [
+    `Pending result${pending.length === 1 ? "" : "s"} (${pending.length}) will stay in schedule history but will not appear in the old source conversation. Its script state will advance when the scheduler settles it.`,
+    ...pending.slice(0, 3).map((item) => {
+      const result = item.result;
+      const finding = result.scriptReport?.summary ?? result.summary ?? result.reason ?? result.status;
+      return `  ${result.runId}: ${sanitizeLine(finding, 180)}`;
+    }),
+    ...pending.length > 3 ? [`  and ${pending.length - 3} more result(s)`] : []
+  ];
+}
+__name(deliveryWaiverLines, "deliveryWaiverLines");
+async function editCommand(ctx, argv) {
+  const args = parseArgs(argv, ADD_FLAGS);
+  if (args.unknown.length > 0 || !args.positionals[0]) {
+    ctx.formatter.error({
+      message: args.unknown.length > 0 ? `unknown option: ${args.unknown.join(", ")}` : "usage: namzu schedule edit <job> [flags]"
+    });
+    return EXIT_USAGE;
+  }
+  const paths = pathsFor(args);
+  try {
+    const current = findJob(paths, args.positionals[0]);
+    const detaching = flag(args, "delivery") === "none";
+    const stateAtReview = readState(paths, current.id);
+    if (detaching && stateAtReview.activeRun?.delivery)
+      throw new JobRequestError(
+        "wait for the source-bound run to finish before removing delivery; its result has not been reviewed yet"
+      );
+    const waiverRunIds = detaching ? pendingSourceRunIds(paths, current.id) : [];
+    if (detaching && !current.delivery && waiverRunIds.length === 0)
+      throw new JobRequestError("this job has no source binding or pending source result to detach");
+    const now = /* @__PURE__ */ new Date();
+    const rebuilt = buildJob(requestFrom(args, current.name, current, waiverRunIds), {
+      paths,
+      config: ctx.config,
+      now,
+      jobId: current.id
+    });
+    const candidate = editedJob(current, rebuilt);
+    const view = /* @__PURE__ */ __name((job) => confirmationView(
+      job,
+      compileJobPolicy(job.permissions, {
+        layers: readPermissionLayers({
+          cwd: job.folder.canonical,
+          env: { ...process.env, NAMZU_HOME: paths.home },
+          ...job.workspace === "none" ? { includeProject: false } : {}
+        }),
+        namzuHome: paths.home
+      }),
+      now
+    ), "view");
+    const changes = [
+      ...changesSinceConfirmed(readHistory(paths, current.id)),
+      ...describeChanges(view(current), view(candidate)),
+      ...deliveryWaiverLines(paths, candidate)
+    ];
+    const surface = await confirmOnTerminal(ctx, paths, candidate, args, "save", changes);
+    if (surface === null) {
+      ctx.formatter.info("Not changed.");
+      return 1;
+    }
+    if (detaching) {
+      const latest = readState(paths, current.id);
+      if (latest.activeRun?.delivery || JSON.stringify(pendingSourceRunIds(paths, current.id)) !== JSON.stringify(waiverRunIds))
+        throw new JobRequestError(
+          "a source-bound run or result changed during review; review the edit again"
+        );
+    }
+    const wasPaused = current.state === "paused";
+    const next = updateJob(
+      paths,
+      current.id,
+      current.revision,
+      () => confirmJob(candidate, surface, now, { paused: wasPaused, paths })
+    );
+    appendHistory(paths, next.id, {
+      v: 1,
+      kind: "job",
+      at: now.toISOString(),
+      action: "edited",
+      by: surface,
+      ...changes.length > 0 ? { changes } : {}
+    });
+    ctx.formatter.print({
+      text: `Saved ${next.name} (${next.state}).`,
+      id: next.id,
+      state: next.state
+    });
+    return EXIT_OK;
+  } catch (error) {
+    ctx.formatter.error({
+      message: visibleScheduleMessage(error instanceof Error ? error.message : String(error))
+    });
+    return error instanceof JobRequestError ? EXIT_USAGE : 1;
+  }
+}
+__name(editCommand, "editCommand");
+async function confirmCommand(ctx, argv) {
+  const args = parseArgs(argv, ["home", "paused!"]);
+  if (args.unknown.length > 0 || !args.positionals[0]) {
+    ctx.formatter.error({
+      message: "usage: namzu schedule confirm <job> [--paused]"
+    });
+    return EXIT_USAGE;
+  }
+  const paths = pathsFor(args);
+  if (!interactive()) {
+    ctx.formatter.error({
+      message: "confirming a job needs a terminal (or the TUI\u2019s /schedule): a confirmation is a person\u2019s, not a script\u2019s"
+    });
+    return EXIT_USAGE;
+  }
+  try {
+    const current = findJob(paths, args.positionals[0]);
+    if (!current.delivery && pendingSourceRunIds(paths, current.id).some(
+      (runId) => !current.deliveryWaiverRunIds?.includes(runId)
+    ))
+      throw new JobRequestError(
+        "a pending source result has not been reviewed for waiver; run schedule edit with --delivery none again"
+      );
+    const surface = await confirmOnTerminal(ctx, paths, current, args, "confirm", [
+      ...changesSinceConfirmed(readHistory(paths, current.id)),
+      ...deliveryWaiverLines(paths, current)
+    ]);
+    if (surface !== "cli-tty") {
+      ctx.formatter.info("Not confirmed.");
+      return 1;
+    }
+    const now = /* @__PURE__ */ new Date();
+    const next = updateJob(
+      paths,
+      current.id,
+      current.revision,
+      (job) => confirmJob(job, "cli-tty", now, { paused: has(args, "paused"), paths })
+    );
+    appendHistory(paths, next.id, {
+      v: 1,
+      kind: "job",
+      at: now.toISOString(),
+      action: "confirmed",
+      by: "cli-tty"
+    });
+    ctx.formatter.print({
+      text: `Confirmed ${next.name} (${next.state}).`,
+      state: next.state
+    });
+    return EXIT_OK;
+  } catch (error) {
+    ctx.formatter.error({
+      message: visibleScheduleMessage(error instanceof Error ? error.message : String(error))
+    });
+    return error instanceof JobRequestError ? EXIT_USAGE : 1;
+  }
+}
+__name(confirmCommand, "confirmCommand");
+export {
+  ADD_FLAGS,
+  addCommand,
+  browserInput,
+  confirmCommand,
+  editCommand
+};
+//# sourceMappingURL=add-DLS54YKS.js.map