@namzu/cli 35.0.0 → 36.1.0

package/dist/chunks/chunk-THZXXVHM.js

@@ -0,0 +1,2953 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+import {
+  DEFAULT_WAKE_GATE_CONTEXT_CHARS,
+  checkJobFolder,
+  checkScratchFolder,
+  computeProjectDigest,
+  folderReadable,
+  plannedScratchFolder,
+  projectDigestChanges,
+  scriptShellUnavailableReason,
+  verifyScheduledScript
+} from "./chunk-KCWUQRZV.js";
+import {
+  CallTally,
+  callsWords
+} from "./chunk-E5VLANCO.js";
+import {
+  allowsWrites,
+  compileJobPolicy,
+  compileScriptCheckPolicy,
+  withheldTools
+} from "./chunk-EIYM6TY7.js";
+import {
+  resumeCommand
+} from "./chunk-HQM2WSQT.js";
+import {
+  appendHistory,
+  compactHistory,
+  foldHistory,
+  readHistory,
+  readState,
+  withoutUndefined,
+  writeState
+} from "./chunk-J72CRUNX.js";
+import {
+  startEndpoint
+} from "./chunk-6YG7D7U4.js";
+import {
+  SCHEDULE_FORMAT_VERSION,
+  confirmationHolds,
+  jobSecurityDigest,
+  listJobs,
+  parseScriptReport,
+  readJob,
+  readScriptState,
+  runResultVersion,
+  sanitizeLine,
+  summaryOf,
+  updateJob,
+  writeScriptState
+} from "./chunk-SKKWMMFP.js";
+import {
+  PRIVATE_FILE_MODE,
+  ensureDir,
+  publishExclusive,
+  readVersioned,
+  writeJsonAtomic
+} from "./chunk-OEW7CJKK.js";
+import {
+  readPermissionLayers
+} from "./chunk-RC6X3ZY6.js";
+import {
+  resolveTrustedProjectContext
+} from "./chunk-CHIEVVQ2.js";
+import {
+  readWslMountRoot
+} from "./chunk-2A37JQKY.js";
+import {
+  pauseWait
+} from "./chunk-XEUQN4JC.js";
+import {
+  describeTurnInterruption,
+  retryAfterMs,
+  unattendedNote
+} from "./chunk-WM2JEUGV.js";
+import {
+  cliLogger,
+  createStderrSink,
+  installCliLogging
+} from "./chunk-HBBB2CAC.js";
+import {
+  archiveConversation,
+  closeSessions,
+  openSessions,
+  readConversationFacts,
+  readIdentity,
+  setTitle,
+  startConversation
+} from "./chunk-TIGWWAJI.js";
+import {
+  DiskSessionLeaseStore,
+  DiskSessionLog,
+  SessionPaths,
+  TurnCancelled,
+  abandonTurn,
+  asSessionId,
+  evaluateJob,
+  execHostShell,
+  generateScheduleRunId,
+  hostTimeZone,
+  installedCommandShellForDialect,
+  isEntityId,
+  isLeaseLive,
+  jsonLinesSink,
+  readSessionLease,
+  releaseHeldSessionLeases,
+  revealHiddenCharacters,
+  scanSchedulePrompt
+} from "./chunk-EWKJGHRO.js";
+import {
+  __name
+} from "./chunk-76FLAFCG.js";
+
+// src/schedule/fire/result.ts
+function writeRunResult(paths, result) {
+  writeJsonAtomic(paths.runResult(result.jobId, result.runId), result);
+}
+__name(writeRunResult, "writeRunResult");
+function readRunResult(paths, jobId, runId) {
+  return readVersioned(
+    paths.runResult(jobId, runId),
+    "schedule-run-result",
+    SCHEDULE_FORMAT_VERSION
+  );
+}
+__name(readRunResult, "readRunResult");
+function isFinal(result) {
+  return result !== void 0 && result.status !== "running";
+}
+__name(isFinal, "isFinal");
+
+// src/schedule/store/claims.ts
+import { readdirSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+function claimOccurrence(paths, claim) {
+  if (!/^(\d{1,16}|manual-[0-9a-f-]{8,64})$/.test(claim.key)) {
+    throw new Error(
+      `Refusing an occurrence key that is not an instant or a manual run: ${claim.key}`
+    );
+  }
+  return publishExclusive(paths.claim(claim.jobId, claim.key), {
+    v: 1,
+    kind: "schedule-claim",
+    ...claim
+  });
+}
+__name(claimOccurrence, "claimOccurrence");
+function isClaimed(paths, jobId, key) {
+  try {
+    statSync(paths.claim(jobId, key));
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isClaimed, "isClaimed");
+function pruneClaims(paths, jobId, maxAgeMs, now = Date.now()) {
+  let removed = 0;
+  let names;
+  try {
+    names = readdirSync(paths.claimsOf(jobId));
+  } catch {
+    return 0;
+  }
+  for (const name of names) {
+    const match = /^(\d{1,16})\.json$/.exec(name);
+    if (!match) continue;
+    if (now - Number(match[1]) > maxAgeMs) {
+      rmSync(join(paths.claimsOf(jobId), name), { force: true });
+      removed++;
+    }
+  }
+  return removed;
+}
+__name(pruneClaims, "pruneClaims");
+
+// src/schedule/daemon/exit.ts
+var EXIT_STOP_REQUESTED = 80;
+
+// src/schedule/daemon/log.ts
+import { appendFileSync, readdirSync as readdirSync2, rmSync as rmSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import { Writable } from "node:stream";
+var KEEP_DAYS = 14;
+function day(now) {
+  return now.toISOString().slice(0, 10);
+}
+__name(day, "day");
+function daemonLogPath(dir, now = /* @__PURE__ */ new Date()) {
+  return join2(dir, `daemon-${day(now)}.jsonl`);
+}
+__name(daemonLogPath, "daemonLogPath");
+function pruneDaemonLogs(dir, now = /* @__PURE__ */ new Date()) {
+  let names;
+  try {
+    names = readdirSync2(dir);
+  } catch {
+    return;
+  }
+  const cutoff = new Date(now.getTime() - KEEP_DAYS * 24 * 60 * 60 * 1e3).toISOString().slice(0, 10);
+  for (const name of names) {
+    const match = /^daemon-(\d{4}-\d{2}-\d{2})\.jsonl$/.exec(name);
+    if (match && match[1] < cutoff) rmSync2(join2(dir, name), { force: true });
+  }
+}
+__name(pruneDaemonLogs, "pruneDaemonLogs");
+function daemonLogSink(dir, now = () => /* @__PURE__ */ new Date()) {
+  ensureDir(dir);
+  const stream = new Writable({
+    write(chunk, _encoding, callback) {
+      try {
+        appendFileSync(daemonLogPath(dir, now()), chunk, { mode: PRIVATE_FILE_MODE });
+        callback();
+      } catch (error) {
+        callback(error);
+      }
+    }
+  });
+  stream.on("error", () => {
+  });
+  return jsonLinesSink(stream);
+}
+__name(daemonLogSink, "daemonLogSink");
+
+// src/schedule/daemon/sessions.ts
+function pathsOf(ref) {
+  return new SessionPaths({ home: ref.home, slug: ref.projectSlug });
+}
+__name(pathsOf, "pathsOf");
+async function sessionLeaseLive(ref, now = Date.now()) {
+  const dir = pathsOf(ref).sessionDir({ sessionId: asSessionId(ref.sessionId) });
+  try {
+    return isLeaseLive(await readSessionLease(dir), now);
+  } catch {
+    return false;
+  }
+}
+__name(sessionLeaseLive, "sessionLeaseLive");
+async function sessionFacts(ref) {
+  try {
+    return await readConversationFacts(
+      { paths: pathsOf(ref) },
+      asSessionId(ref.sessionId),
+      "tolerant"
+    );
+  } catch {
+    return null;
+  }
+}
+__name(sessionFacts, "sessionFacts");
+function turnOutcome(facts, turnId) {
+  for (let i = facts.records.length - 1; i >= 0; i--) {
+    const record = facts.records[i];
+    if (turnId && record.turnId !== turnId) continue;
+    if (record.type === "turn_completed") return { status: "completed" };
+    if (record.type === "turn_failed") {
+      return {
+        status: "failed",
+        ...record.error?.message ? { reason: record.error.message } : {}
+      };
+    }
+  }
+  return void 0;
+}
+__name(turnOutcome, "turnOutcome");
+async function abandonParkedTurn(ref, turnId, reason) {
+  const log = DiskSessionLog.at(pathsOf(ref), { sessionId: asSessionId(ref.sessionId) });
+  await abandonTurn(asSessionId(ref.sessionId), turnId, reason, { log });
+}
+__name(abandonParkedTurn, "abandonParkedTurn");
+
+// src/schedule/daemon/daemon.ts
+import { spawn } from "node:child_process";
+import {
+  closeSync,
+  existsSync,
+  openSync,
+  rmSync as rmSync3,
+  statSync as statSync4,
+  watch,
+  writeFileSync
+} from "node:fs";
+import { dirname, join as join4 } from "node:path";
+
+// src/integrations/notifications/desktop/throttle.ts
+import { readFileSync } from "node:fs";
+var PER_JOB_MS = 10 * 6e4;
+var PER_DAY = 20;
+var DAY_MS = 24 * 60 * 6e4;
+function read(path) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed.kind === "schedule-notify" && Array.isArray(parsed.sent)) return parsed;
+  } catch {
+  }
+  return { v: 1, kind: "schedule-notify", sent: [], suppressed: 0 };
+}
+__name(read, "read");
+function admitNotification(path, jobId, now = Date.now()) {
+  const file = read(path);
+  const recent = file.sent.filter((s) => now - s.at < DAY_MS);
+  const jobRecent = recent.some((s) => s.jobId === jobId && now - s.at < PER_JOB_MS);
+  if (jobRecent || recent.length >= PER_DAY) {
+    writeJsonAtomic(path, { ...file, sent: recent, suppressed: file.suppressed + 1 });
+    return false;
+  }
+  writeJsonAtomic(path, { ...file, sent: [...recent, { jobId, at: now }] });
+  return true;
+}
+__name(admitNotification, "admitNotification");
+function takeSuppressedCount(path) {
+  const file = read(path);
+  if (file.suppressed > 0) writeJsonAtomic(path, { ...file, suppressed: 0 });
+  return file.suppressed;
+}
+__name(takeSuppressedCount, "takeSuppressedCount");
+
+// src/schedule/delivery.ts
+import { createHash, randomUUID } from "node:crypto";
+import { readFileSync as readFileSync2, readdirSync as readdirSync3, statSync as statSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+var DELIVERY_SUMMARY_CHARS = 600;
+var DELIVERY_REASON_CHARS = 300;
+var DELIVERY_READ_LIMIT = 100;
+var UUID = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/;
+var FINAL_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "failed",
+  "awaiting-approval",
+  "approval-expired",
+  "interrupted",
+  "timed-out",
+  "blocked-config",
+  "cancelled",
+  "check-failed"
+]);
+function id(value) {
+  return UUID.test(value);
+}
+__name(id, "id");
+function sourcePaths(paths, source) {
+  return new SessionPaths({ home: paths.home, slug: source.projectSlug });
+}
+__name(sourcePaths, "sourcePaths");
+function deliveryDir(paths, source) {
+  if (!isEntityId(source.sessionId, "session")) throw new Error("invalid source session id");
+  return join3(paths.root, "deliveries", source.sessionId);
+}
+__name(deliveryDir, "deliveryDir");
+function eventKey(delivery) {
+  return createHash("sha256").update(JSON.stringify([delivery.jobId, delivery.runId, delivery.status, delivery.at])).digest("hex");
+}
+__name(eventKey, "eventKey");
+function eventFile(paths, delivery) {
+  return join3(deliveryDir(paths, delivery.source), `${eventKey(delivery)}.json`);
+}
+__name(eventFile, "eventFile");
+function sameSource(a, b) {
+  return a.kind === b.kind && a.sessionId === b.sessionId && a.projectSlug === b.projectSlug && a.projectId === b.projectId && a.tenantId === b.tenantId;
+}
+__name(sameSource, "sameSource");
+async function sourceProblem(paths, source) {
+  if (source.kind !== "source-conversation" || !isEntityId(source.sessionId, "session") || !isEntityId(source.projectId, "project") || !isEntityId(source.tenantId, "tenant"))
+    return "the source conversation binding is invalid";
+  let sessionPaths;
+  try {
+    sessionPaths = sourcePaths(paths, source);
+  } catch {
+    return "the source project slug is invalid";
+  }
+  const identity = readIdentity(paths.home);
+  if (!identity || identity.tenantId !== source.tenantId)
+    return "the source conversation belongs to another installation";
+  let project;
+  try {
+    project = JSON.parse(readFileSync2(sessionPaths.projectFile(), "utf8"));
+  } catch {
+    return "the source project is missing or unreadable";
+  }
+  if (!project || typeof project !== "object" || project.projectId !== source.projectId || project.slug !== source.projectSlug)
+    return "the source project no longer matches its binding";
+  const facts = await readConversationFacts({ paths: sessionPaths }, asSessionId(source.sessionId));
+  if (!facts) return "the source conversation is missing";
+  if (facts.started.projectId !== source.projectId || // Legacy session_started records had no tenant. The installation identity
+  // and exact project were already checked above; an explicit different
+  // tenant in the log still rejects the binding.
+  facts.started.tenantId !== void 0 && facts.started.tenantId !== source.tenantId || facts.started.cwd !== project.cwd)
+    return "the source conversation no longer matches its binding";
+  if (facts.archived) return "the source conversation is archived";
+  return void 0;
+}
+__name(sourceProblem, "sourceProblem");
+function scriptSummary(result) {
+  const stdout = result.scriptOutput?.stdout;
+  if (!stdout) return "";
+  const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i];
+    if (!(line.startsWith("{") && line.endsWith("}"))) return line;
+  }
+  return "";
+}
+__name(scriptSummary, "scriptSummary");
+function deliveryFor(job, result) {
+  const source = job.delivery;
+  if (!source || result.status === "running" || result.status === "completed" && result.scriptReport?.state === "quiet" || result.status === "completed" && result.gateResult?.wake === false)
+    return void 0;
+  const summary = sanitizeLine(
+    result.summary || result.scriptReport?.summary || scriptSummary(result),
+    DELIVERY_SUMMARY_CHARS
+  );
+  const calls = result.refusedCalls ?? result.failedCalls;
+  const callNote = calls ? `${calls.count} ${result.refusedCalls ? "refused" : "failed"} call${calls.count === 1 ? "" : "s"}; first: ${calls.first.tool}: ${calls.first.reason}` : "";
+  const reason = sanitizeLine(result.reason ?? callNote, DELIVERY_REASON_CHARS);
+  const noteworthy = result.status !== "completed" || Boolean(summary || reason || result.refusedCalls || result.failedCalls);
+  if (!noteworthy) return void 0;
+  const at = result.endedAt ?? result.startedAt;
+  return {
+    v: 1,
+    kind: "schedule-source-delivery",
+    source: { ...source },
+    jobId: job.id,
+    jobName: sanitizeLine(job.name, 80),
+    runId: result.runId,
+    ...result.sessionId ? { runSessionId: result.sessionId } : {},
+    status: result.status,
+    at,
+    ...summary ? { summary } : {},
+    ...reason ? { reason } : {}
+  };
+}
+__name(deliveryFor, "deliveryFor");
+function validDelivery(value, source) {
+  return value.v === 1 && value.kind === "schedule-source-delivery" && value.source !== null && typeof value.source === "object" && sameSource(value.source, source) && id(value.jobId) && id(value.runId) && typeof value.jobName === "string" && [...value.jobName].length <= 80 && FINAL_STATUSES.has(value.status) && Number.isFinite(Date.parse(value.at)) && (value.publishedOrder === void 0 || Number.isSafeInteger(value.publishedOrder) && value.publishedOrder >= 0) && (value.runSessionId === void 0 || isEntityId(value.runSessionId, "session")) && (value.summary === void 0 || typeof value.summary === "string" && [...value.summary].length <= DELIVERY_SUMMARY_CHARS) && (value.reason === void 0 || typeof value.reason === "string" && [...value.reason].length <= DELIVERY_REASON_CHARS);
+}
+__name(validDelivery, "validDelivery");
+function inboxFiles(paths, source) {
+  const dir = deliveryDir(paths, source);
+  try {
+    return {
+      dir,
+      names: readdirSync3(dir).filter((name) => /^[a-f0-9]{64}\.json$/.test(name))
+    };
+  } catch (error) {
+    if (error.code === "ENOENT") return { dir, names: [] };
+    throw error;
+  }
+}
+__name(inboxFiles, "inboxFiles");
+function inboxRecords(paths, source) {
+  const { dir, names } = inboxFiles(paths, source);
+  return names.map((name) => {
+    const file = join3(dir, name);
+    const entry = readVersioned(file, "schedule-source-delivery", 1);
+    if (!entry || !validDelivery(entry, source) || `${eventKey(entry)}.json` !== name)
+      throw new Error(`${file} is not a delivery for this source conversation`);
+    const age = entry.publishedOrder === void 0 ? statSync2(file) : void 0;
+    const order = entry.publishedOrder ?? (age && age.birthtimeMs > 0 ? age.birthtimeMs : age?.mtimeMs ?? 0);
+    return { entry, name, order };
+  });
+}
+__name(inboxRecords, "inboxRecords");
+function compareRecord(a, b) {
+  return a.order - b.order || a.name.localeCompare(b.file);
+}
+__name(compareRecord, "compareRecord");
+function nextPublicationOrder(paths, source) {
+  const { dir, names } = inboxFiles(paths, source);
+  let latest = 0;
+  for (const name of names) {
+    const file = join3(dir, name);
+    const age = statSync2(file);
+    let order = age.birthtimeMs > 0 ? age.birthtimeMs : age.mtimeMs;
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync2(file, "utf8"));
+    } catch (error) {
+      if (error.code) throw error;
+    }
+    try {
+      const entry = parsed;
+      if (entry && validDelivery(entry, source) && `${eventKey(entry)}.json` === name && entry.publishedOrder !== void 0)
+        order = entry.publishedOrder;
+    } catch {
+    }
+    latest = Math.max(latest, order);
+  }
+  const next = Math.max(Date.now(), Math.floor(latest) + 1);
+  if (!Number.isSafeInteger(next)) throw new Error("source delivery publication order is exhausted");
+  return next;
+}
+__name(nextPublicationOrder, "nextPublicationOrder");
+async function deliverRunToSource(paths, job, result) {
+  if (!job.delivery) return { kind: "quiet" };
+  if (result.jobId !== job.id || !id(job.id) || !id(result.runId))
+    return { kind: "rejected", reason: "the run does not match its source job" };
+  const delivery = deliveryFor(job, result);
+  if (!delivery) return { kind: "quiet" };
+  if (!Number.isFinite(Date.parse(delivery.at)))
+    return { kind: "rejected", reason: "the run result has no valid time" };
+  let file;
+  try {
+    file = eventFile(paths, delivery);
+    const existing = readVersioned(file, "schedule-source-delivery", 1);
+    if (existing) {
+      return validDelivery(existing, job.delivery) && eventKey(existing) === eventKey(delivery) ? { kind: "already-delivered" } : { kind: "rejected", reason: "a different delivery already owns this run event" };
+    }
+  } catch (error) {
+    return { kind: "rejected", reason: error instanceof Error ? error.message : String(error) };
+  }
+  let sessionPaths;
+  try {
+    sessionPaths = sourcePaths(paths, job.delivery);
+    const problem = await sourceProblem(paths, job.delivery);
+    if (problem) return { kind: "rejected", reason: problem };
+  } catch (error) {
+    return { kind: "rejected", reason: error instanceof Error ? error.message : String(error) };
+  }
+  const log = DiskSessionLog.at(sessionPaths, { sessionId: asSessionId(job.delivery.sessionId) });
+  let lease;
+  try {
+    lease = await log.claim({
+      holder: `namzu-schedule-delivery:${process.pid}:${randomUUID()}`,
+      ttlMs: 3e4,
+      repairTornTail: false
+    });
+  } catch (error) {
+    return { kind: "retry", reason: error instanceof Error ? error.message : String(error) };
+  }
+  if (!lease) return { kind: "retry", reason: "the source conversation is busy" };
+  try {
+    const problem = await sourceProblem(paths, job.delivery);
+    if (problem) return { kind: "rejected", reason: problem };
+    const published = {
+      ...delivery,
+      publishedOrder: nextPublicationOrder(paths, job.delivery)
+    };
+    const renewed = await log.claim({
+      holder: lease.holder,
+      ttlMs: 3e4,
+      repairTornTail: false
+    });
+    if (!renewed || renewed.fence !== lease.fence)
+      return { kind: "retry", reason: "the source conversation lease changed" };
+    if (!publishExclusive(file, published)) {
+      const existing = readVersioned(file, "schedule-source-delivery", 1);
+      if (!existing || !validDelivery(existing, job.delivery) || eventKey(existing) !== eventKey(delivery))
+        return { kind: "rejected", reason: "a different delivery already owns this run event" };
+      return { kind: "already-delivered" };
+    }
+    return { kind: "delivered" };
+  } catch (error) {
+    return { kind: "retry", reason: error instanceof Error ? error.message : String(error) };
+  } finally {
+    await log.release(lease);
+  }
+}
+__name(deliverRunToSource, "deliverRunToSource");
+async function readSourceDeliveryPage(paths, source, after) {
+  const problem = await sourceProblem(paths, source);
+  if (problem) throw new Error(problem);
+  const records = inboxRecords(paths, source).sort((a, b) => a.order - b.order || a.name.localeCompare(b.name)).filter((record) => after === void 0 || compareRecord(record, after) > 0);
+  const page = records.slice(0, DELIVERY_READ_LIMIT);
+  const last = page.at(-1);
+  return {
+    entries: page.map((record) => record.entry),
+    ...last ? { cursor: { order: last.order, file: last.name } } : after ? { cursor: after } : {},
+    hasMore: records.length > DELIVERY_READ_LIMIT
+  };
+}
+__name(readSourceDeliveryPage, "readSourceDeliveryPage");
+
+// src/schedule/env.ts
+import { readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
+var CHILD_ENV_ALLOWLIST = [
+  "HOME",
+  "USER",
+  "LOGNAME",
+  "LANG",
+  "LC_ALL",
+  "TZ",
+  "TMPDIR",
+  "SHELL",
+  "XDG_RUNTIME_DIR",
+  "XDG_CONFIG_HOME",
+  "DBUS_SESSION_BUS_ADDRESS",
+  "WSL_DISTRO_NAME",
+  "WSL_INTEROP",
+  "SystemRoot",
+  "USERPROFILE",
+  "APPDATA",
+  "LOCALAPPDATA",
+  // A job with `browser.headed` opens a window: X11, Wayland (WSLg sets
+  // both), and the X authority file a display may need.
+  "DISPLAY",
+  "WAYLAND_DISPLAY",
+  "XAUTHORITY"
+];
+function stripWindowsMounts(path, mountRoot = readWslMountRoot()) {
+  const root = mountRoot.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const drive = new RegExp(`^${root}[a-z](/|$)`, "i");
+  return (path ?? "").split(":").filter((entry) => entry !== "" && !drive.test(entry)).join(":");
+}
+__name(stripWindowsMounts, "stripWindowsMounts");
+function childEnvironment(source, namzuHome, mountRoot) {
+  const env = {};
+  for (const key of CHILD_ENV_ALLOWLIST) if (source[key] !== void 0) env[key] = source[key];
+  env.PATH = process.platform === "win32" ? source.PATH ?? source.Path ?? "" : stripWindowsMounts(source.PATH, mountRoot);
+  if (!env.PATH) env.PATH = "/usr/local/bin:/usr/bin:/bin";
+  env.NAMZU_HOME = namzuHome;
+  return env;
+}
+__name(childEnvironment, "childEnvironment");
+function readDaemonEnv(path) {
+  let text;
+  try {
+    text = readFileSync3(path, "utf8");
+  } catch {
+    return { values: {}, warnings: [] };
+  }
+  const warnings = [];
+  try {
+    const mode = statSync3(path).mode & 63;
+    if (mode !== 0 && process.platform !== "win32") {
+      warnings.push(`${path} can be read by other users; run chmod 600 on it`);
+    }
+  } catch {
+  }
+  const values = {};
+  text.split(/\r?\n/).forEach((raw, index) => {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) return;
+    const match = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(line);
+    if (!match) {
+      warnings.push(`${path}:${index + 1} is not KEY=value; ignored`);
+      return;
+    }
+    let value = match[2] ?? "";
+    if (value.length >= 2 && (value[0] === '"' || value[0] === "'") && value.at(-1) === value[0]) {
+      value = value.slice(1, -1);
+    }
+    values[match[1]] = value;
+  });
+  return { values, warnings };
+}
+__name(readDaemonEnv, "readDaemonEnv");
+
+// src/schedule/daemon/notify.ts
+function clock(at) {
+  return new Intl.DateTimeFormat("en-GB", {
+    weekday: "short",
+    hour: "2-digit",
+    minute: "2-digit"
+  }).format(at);
+}
+__name(clock, "clock");
+var NOTICE_BODY_MAX = 200;
+function noticeText(kind, job, extra) {
+  const title = `namzu: ${job.name}`;
+  const when = clock(extra.at);
+  const summary = job.notify.includeSummary && extra.summary ? ` \u2014 ${extra.summary}` : "";
+  switch (kind) {
+    case "finished": {
+      const refused = extra.refused;
+      if (!refused) return { title, body: `finished at ${when}${summary}` };
+      const done = `done at ${when}, but ${callsWords(refused, "refused")}`;
+      if (!job.notify.includeSummary)
+        return {
+          title,
+          body: fit(
+            `${done} (${refused.first.tool}); namzu schedule show ${job.name} says why`,
+            `${done} (${refused.first.tool})`
+          )
+        };
+      const head = `${done}: `;
+      const room = NOTICE_BODY_MAX - [...head].length - [...summary].length;
+      const reason = [...refused.first.reason];
+      const said = reason.length <= room ? refused.first.reason : `${reason.slice(0, Math.max(room - 1, 0)).join("")}\u2026`;
+      return { title, body: fit(`${head}${said}${summary}`, `${head}${said}`) };
+    }
+    case "failed":
+      return { title, body: `failed at ${when}${summary}` };
+    case "check-failed": {
+      if (!job.notify.includeSummary || !extra.reason) {
+        return {
+          title,
+          body: `check failed at ${when}; namzu schedule show ${job.name} says why`
+        };
+      }
+      const head = `check failed at ${when}: `;
+      const room = NOTICE_BODY_MAX - [...head].length;
+      const safeReason = sanitizeLine(extra.reason, 1e3);
+      const reason = [...safeReason];
+      const said = reason.length <= room ? safeReason : `${reason.slice(0, Math.max(room - 1, 0)).join("")}\u2026`;
+      return { title, body: fit(`${head}${said}`, `check failed at ${when}`) };
+    }
+    case "timed-out":
+      return { title, body: `stopped at its time limit at ${when}` };
+    case "interrupted":
+      return { title, body: `was interrupted at ${when}` };
+    case "blocked-config":
+      return {
+        title,
+        body: `could not start at ${when}: check it with namzu schedule show ${job.name}`
+      };
+    case "awaiting-approval": {
+      if (extra.handoff) {
+        const needs = `needs you (since ${when}): ${extra.handoff}`;
+        const candidates = [
+          ...extra.resumeCommand ? [`${needs}; continue it: ${extra.resumeCommand}`] : [],
+          `${needs}; namzu schedule show ${job.name} says how to continue it`,
+          needs
+        ];
+        const body = candidates.find((text) => [...text].length <= NOTICE_BODY_MAX);
+        return {
+          title,
+          body: body ?? `${[...needs].slice(0, NOTICE_BODY_MAX - 1).join("")}\u2026`
+        };
+      }
+      const waiting = `is waiting for your approval (since ${when})`;
+      const answer = extra.resumeCommand ? `${waiting}; answer it: ${extra.resumeCommand}` : void 0;
+      return {
+        title,
+        body: answer && [...answer].length <= NOTICE_BODY_MAX ? answer : `${waiting}; namzu schedule show ${job.name} says how to answer it`
+      };
+    }
+    case "approval-expired":
+      return { title, body: `approval expired at ${when}; the run was abandoned` };
+    case "catch-up":
+      return {
+        title,
+        body: `catch-up run for ${extra.scheduledFor ? clock(extra.scheduledFor) : "a missed time"}${extra.missed ? `, ${extra.missed} earlier runs missed` : ""}`
+      };
+    case "held":
+      return { title, body: "changed outside namzu and is on hold; confirm it with /schedule" };
+    case "needs-confirmation":
+      return { title, body: "needs confirmation before it runs; open /schedule" };
+    case "auto-paused":
+      return { title, body: `paused after ${extra.failures ?? "several"} failed runs in a row` };
+  }
+}
+__name(noticeText, "noticeText");
+function fit(...candidates) {
+  const whole = candidates.find((text) => [...text].length <= NOTICE_BODY_MAX);
+  if (whole !== void 0) return whole;
+  const last = [...candidates.at(-1) ?? ""];
+  return `${last.slice(0, NOTICE_BODY_MAX - 1).join("")}\u2026`;
+}
+__name(fit, "fit");
+function scriptSummaryOf(result) {
+  const stdout = result.scriptOutput?.stdout;
+  if (!stdout) return void 0;
+  const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i];
+    const looksLikeContract = line.startsWith("{") && line.endsWith("}");
+    if (!looksLikeContract) return sanitizeLine(line, 200);
+  }
+  return void 0;
+}
+__name(scriptSummaryOf, "scriptSummaryOf");
+function failureSignature(status, reason) {
+  const normal = (reason ?? "").toLowerCase().replace(/[0-9a-f]{8}-[0-9a-f-]{27,}/g, "<id>").replace(/\d+/g, "<n>").replace(/\s+/g, " ").slice(0, 160);
+  return `${status}:${normal}`;
+}
+__name(failureSignature, "failureSignature");
+
+// src/schedule/daemon/retention.ts
+function sessionsToArchive(paths, job, state) {
+  const done = new Set(state.archivedSessions ?? []);
+  const completed = foldHistory(readHistory(paths, job.id)).filter(
+    (r) => r.kind === "run" && r.status === "completed" && typeof r.sessionId === "string"
+  );
+  return completed.slice(Math.max(0, job.retention.keepSessions)).map((r) => r.sessionId).filter((id2) => !done.has(id2));
+}
+__name(sessionsToArchive, "sessionsToArchive");
+async function archiveOldRuns(paths, job, state) {
+  const ids = sessionsToArchive(paths, job, state);
+  if (ids.length === 0) return [];
+  const sessions = await openSessions(job.folder.canonical, { stateRoot: paths.home });
+  const archived = [];
+  try {
+    for (const id2 of ids) {
+      try {
+        await archiveConversation(sessions, asSessionId(id2));
+        archived.push(id2);
+      } catch (error) {
+        if (error instanceof Error && /already archived/.test(error.message)) archived.push(id2);
+      }
+    }
+  } finally {
+    closeSessions(sessions);
+  }
+  return archived;
+}
+__name(archiveOldRuns, "archiveOldRuns");
+
+// src/schedule/daemon/daemon.ts
+var LEASE_TTL_MS = 9e4;
+var LEASE_RENEW_MS = 3e4;
+var TICK_MS = 3e4;
+var START_GRACE_MS = 12e4;
+var SCRIPT_EXIT_MARGIN_MS = 6e4;
+var CLAIM_RETENTION_EXTRA_MS = 24 * 60 * 60 * 1e3;
+var HOUSEKEEPING_MS = 24 * 60 * 60 * 1e3;
+var GAP_MS = 6e4;
+function pendingResultKey(item) {
+  return JSON.stringify([
+    item.result.runId,
+    item.result.status,
+    item.result.endedAt,
+    item.delivery?.sessionId
+  ]);
+}
+__name(pendingResultKey, "pendingResultKey");
+function noSessionStartGraceMs(job) {
+  if (job.runKind !== "script" && job.runKind !== "script+agent") return START_GRACE_MS;
+  const timeout = job.script?.timeoutMs;
+  if (!timeout || !Number.isSafeInteger(timeout) || timeout <= 0) return START_GRACE_MS;
+  return Math.max(
+    START_GRACE_MS,
+    Math.min(timeout, Number.MAX_SAFE_INTEGER - SCRIPT_EXIT_MARGIN_MS) + SCRIPT_EXIT_MARGIN_MS
+  );
+}
+__name(noSessionStartGraceMs, "noSessionStartGraceMs");
+var ScheduleDaemon = class {
+  static {
+    __name(this, "ScheduleDaemon");
+  }
+  #o;
+  #now;
+  #mono;
+  #leaseStore;
+  #lease = null;
+  #leaseRenewedAt = 0;
+  #endpoint;
+  #watcher;
+  /** Runs in progress: ours (with a handle) and adopted ones (without). */
+  #running = /* @__PURE__ */ new Map();
+  #stopping = false;
+  /** The stop came from `schedule stop`'s file, not a signal or the endpoint. */
+  #stopRequestedByFile = false;
+  #draining = false;
+  #standby = false;
+  #wake;
+  #lastWall = 0;
+  #lastMono = 0;
+  #startedAt = 0;
+  #observedGap;
+  #startFingerprint = "";
+  #lastHousekeeping = 0;
+  #manual = [];
+  /** Why a queued run is waiting, for its run record once it starts. */
+  #delayReasons = /* @__PURE__ */ new Map();
+  #finalizing = [];
+  /** Keep exit finalization behind a tick that still holds an older state snapshot. */
+  #stateTail = Promise.resolve();
+  constructor(options) {
+    this.#o = options;
+    this.#now = options.now ?? Date.now;
+    this.#mono = options.monotonic ?? (() => performance.now());
+    this.#leaseStore = new DiskSessionLeaseStore(options.paths.daemon);
+  }
+  get standby() {
+    return this.#standby;
+  }
+  get lease() {
+    return this.#lease;
+  }
+  /** Ask the loop to stop at its next wake. Running children are left running. */
+  stop() {
+    this.#stopping = true;
+    this.#wake?.();
+  }
+  /** Stop dispatching, wait for our own runs, then stop (an upgrade restart). */
+  drainAndRestart() {
+    this.#draining = true;
+    this.#persistManual();
+    this.#wake?.();
+  }
+  wake() {
+    this.#wake?.();
+  }
+  /** Try once to own the home (for a caller driving {@link tick} itself). */
+  async claimOwnership() {
+    this.#startFingerprint ||= this.#o.fingerprint();
+    this.#startedAt ||= this.#now();
+    const lease = await this.#leaseStore.claim({
+      holder: this.#o.epoch,
+      ttlMs: this.#o.leaseTtlMs ?? LEASE_TTL_MS,
+      now: this.#now()
+    });
+    if (lease) {
+      this.#lease = lease;
+      this.#leaseRenewedAt = this.#now();
+    }
+    return lease !== null;
+  }
+  /** Give the home up (a caller driving {@link tick} itself). */
+  async releaseOwnership() {
+    if (this.#lease) await this.#leaseStore.release(this.#lease);
+    this.#lease = null;
+  }
+  /** Run until stopped. Returns the process exit code. */
+  async run() {
+    ensureDir(this.#o.paths.daemon);
+    this.#startedAt = this.#now();
+    this.#startFingerprint = this.#o.fingerprint();
+    for (; ; ) {
+      const acquired = await this.#acquire();
+      if (acquired === "exit75") return 75;
+      if (acquired === "stopped") return this.#stopRequestedByFile ? EXIT_STOP_REQUESTED : 0;
+      const outcome = await this.#own();
+      if (outcome === "standby") continue;
+      return this.#stopRequestedByFile ? EXIT_STOP_REQUESTED : 0;
+    }
+  }
+  async #acquire() {
+    let announced = false;
+    for (; ; ) {
+      if (this.#stopRequested()) this.#stopping = true;
+      if (this.#stopping) return "stopped";
+      const lease = await this.#leaseStore.claim({
+        holder: this.#o.epoch,
+        ttlMs: this.#o.leaseTtlMs ?? LEASE_TTL_MS,
+        now: this.#now()
+      });
+      if (lease) {
+        this.#lease = lease;
+        this.#leaseRenewedAt = this.#now();
+        this.#standby = false;
+        this.#o.log.info("scheduler owns this home", {
+          "namzu.schedule.epoch": this.#o.epoch,
+          "namzu.schedule.fence": lease.fence
+        });
+        return "owned";
+      }
+      if (this.#o.onceOrExit) {
+        this.#o.log.warn("another scheduler owns this home", {
+          "namzu.schedule.epoch": this.#o.epoch
+        });
+        return "exit75";
+      }
+      this.#standby = true;
+      if (!announced) {
+        announced = true;
+        this.#o.log.info("scheduler on standby", { "namzu.schedule.epoch": this.#o.epoch });
+      }
+      await this.#sleep(this.#o.standbyPollMs ?? LEASE_RENEW_MS);
+    }
+  }
+  async #own() {
+    this.#endpoint = await startEndpoint(this.#o.paths.endpoint, this.#o.epoch, {
+      status: /* @__PURE__ */ __name(() => this.status(), "status"),
+      reload: /* @__PURE__ */ __name(() => this.wake(), "reload"),
+      runNow: /* @__PURE__ */ __name((jobId) => this.requestRunNow(jobId), "runNow"),
+      stop: /* @__PURE__ */ __name(() => this.stop(), "stop"),
+      drainAndRestart: /* @__PURE__ */ __name(() => this.drainAndRestart(), "drainAndRestart")
+    });
+    if (this.#o.watchJobs !== false) {
+      try {
+        ensureDir(this.#o.paths.jobs);
+        this.#watcher = watch(this.#o.paths.jobs, () => this.wake());
+        this.#watcher.on("error", () => {
+        });
+      } catch {
+      }
+    }
+    this.#lastWall = this.#now();
+    this.#lastMono = this.#mono();
+    try {
+      for (; ; ) {
+        if (this.#stopRequested()) this.#stopping = true;
+        if (this.#stopping) return "stopped";
+        if (!await this.#holdLease()) {
+          this.#o.log.warn("scheduler lost its lease; standing by", {
+            "namzu.schedule.epoch": this.#o.epoch
+          });
+          return "standby";
+        }
+        await this.tick();
+        if (this.#draining && this.#ownRuns() === 0) {
+          this.#o.log.info("scheduler drained for a restart", {
+            "namzu.schedule.epoch": this.#o.epoch
+          });
+          this.#stopping = true;
+          return "stopped";
+        }
+        await this.#sleep(this.#nextSleep());
+      }
+    } finally {
+      this.#watcher?.close();
+      await this.#endpoint?.close();
+      this.#endpoint = void 0;
+      await this.#stateTail;
+      await Promise.allSettled(this.#finalizing);
+      if (this.#stopping) this.#persistManual();
+      if (this.#lease && this.#stopping) {
+        await this.#leaseStore.release(this.#lease).catch(() => void 0);
+        this.#lease = null;
+      }
+      this.#heartbeat();
+    }
+  }
+  /**
+   * `schedule stop` and `uninstall` leave `daemon/stop.json`; `start` and
+   * `install` remove it. It reaches a daemon the service manager cannot: one
+   * on standby (it has no endpoint), or one under WSL, whose Windows task
+   * ending does not end the Linux process. A daemon that finds it exits
+   * {@link EXIT_STOP_REQUESTED}.
+   */
+  #stopRequested() {
+    if (!existsSync(stopRequestPath(this.#o.paths))) return false;
+    this.#stopRequestedByFile = true;
+    this.#o.log.info("scheduler stop requested", { "namzu.schedule.epoch": this.#o.epoch });
+    return true;
+  }
+  #ownRuns() {
+    let n = 0;
+    for (const t of this.#running.values()) if (t.run) n++;
+    return n;
+  }
+  /** Renew when due; true while this daemon's fence is still the highest. */
+  async #holdLease() {
+    const lease = this.#lease;
+    if (!lease) return false;
+    if (this.#now() - this.#leaseRenewedAt >= LEASE_RENEW_MS) {
+      const renewed = await this.#leaseStore.claim(
+        { holder: this.#o.epoch, ttlMs: this.#o.leaseTtlMs ?? LEASE_TTL_MS, now: this.#now() },
+        { renew: lease }
+      );
+      if (!renewed) {
+        this.#lease = null;
+        return false;
+      }
+      this.#lease = renewed;
+      this.#leaseRenewedAt = this.#now();
+    }
+    return this.#stillOwner();
+  }
+  async #stillOwner() {
+    const lease = this.#lease;
+    return lease !== null && await this.#leaseStore.fence() === lease.fence;
+  }
+  #sleep(ms) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(
+        () => {
+          this.#wake = void 0;
+          resolve();
+        },
+        Math.max(10, ms)
+      );
+      this.#wake = () => {
+        clearTimeout(timer);
+        this.#wake = void 0;
+        resolve();
+      };
+    });
+  }
+  #nextSleep() {
+    const tick = this.#o.tickMs ?? TICK_MS;
+    let soonest = this.#now() + tick;
+    for (const job of listJobs(this.#o.paths).jobs) {
+      try {
+        const next = readState(this.#o.paths, job.id).nextFireAt;
+        if (next) soonest = Math.min(soonest, Date.parse(next) + 50);
+      } catch {
+      }
+    }
+    return Math.max(50, Math.min(tick, soonest - this.#now()));
+  }
+  /** What the endpoint's `status` reports. */
+  status() {
+    return {
+      epoch: this.#o.epoch,
+      pid: process.pid,
+      version: this.#o.version,
+      fence: this.#lease?.fence,
+      standby: this.#standby,
+      draining: this.#draining,
+      runs: [...this.#running.values()].map((t) => ({
+        jobId: t.jobId,
+        runId: t.runId,
+        adopted: t.run === void 0
+      })),
+      notifications: this.#o.notificationBackend ?? "unknown"
+    };
+  }
+  /** Queue a manual run (`schedule run-now`). Refused while the job has a run. */
+  requestRunNow(jobId) {
+    const job = readJob(this.#o.paths, jobId);
+    if (!job) return { ok: false, message: `no job ${jobId}` };
+    if (job.state !== "active" || !confirmationHolds(job)) {
+      return {
+        ok: false,
+        message: `${job.name} is ${job.state === "active" ? "awaiting confirmation" : job.state}`
+      };
+    }
+    const state = readState(this.#o.paths, job.id);
+    if (state.activeRun || state.queued || this.#manual.some((m) => m.jobId === job.id)) {
+      return { ok: false, message: `${job.name} already has a run` };
+    }
+    this.#manual.push({ jobId: job.id, runId: generateScheduleRunId() });
+    if (this.#draining) {
+      this.#persistManual();
+      return {
+        ok: true,
+        message: `${job.name} queued; the scheduler is restarting for an upgrade and starts it once it is back`
+      };
+    }
+    this.wake();
+    return { ok: true, message: `${job.name} queued` };
+  }
+  /**
+   * Move every manual run still waiting in memory (deferred by the cap or a
+   * busy folder lane) to `state.queued` on disk. A daemon that stops
+   * dispatching (a drain) or exits keeps no memory, and the CLI has already
+   * told the operator the run is queued; the daemon that takes over starts
+   * it from disk under the same run id.
+   */
+  #persistManual() {
+    for (const manual of this.#manual.splice(0)) {
+      try {
+        const state = readState(this.#o.paths, manual.jobId);
+        if (state.activeRun || state.queued) {
+          this.#o.log.warn("manual run dropped; the job already has a run", {
+            "namzu.schedule.job_id": manual.jobId,
+            "namzu.schedule.run_id": manual.runId
+          });
+          continue;
+        }
+        const at = new Date(this.#now()).toISOString();
+        writeState(this.#o.paths, {
+          ...state,
+          queued: {
+            key: `${MANUAL_KEY_PREFIX}${manual.runId}`,
+            scheduledFor: at,
+            trigger: "manual",
+            queuedAt: at
+          }
+        });
+      } catch (error) {
+        this.#o.log.error("manual run could not be queued on disk", {
+          "namzu.schedule.job_id": manual.jobId,
+          "namzu.schedule.run_id": manual.runId,
+          "exception.message": error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  #heartbeat() {
+    try {
+      writeJsonAtomic(this.#o.paths.heartbeat, {
+        v: 1,
+        kind: "schedule-heartbeat",
+        at: new Date(this.#now()).toISOString(),
+        pid: process.pid,
+        epoch: this.#o.epoch,
+        version: this.#o.version,
+        standby: this.#standby,
+        draining: this.#draining,
+        runsInFlight: this.#running.size,
+        notifications: this.#o.notificationBackend ?? "unknown"
+      });
+    } catch {
+    }
+  }
+  #observeClock() {
+    const wall = this.#now();
+    const mono = this.#mono();
+    const wallDelta = wall - this.#lastWall;
+    const monoDelta = mono - this.#lastMono;
+    if (wallDelta - monoDelta > GAP_MS) {
+      this.#observedGap = {
+        from: new Date(this.#lastWall),
+        to: new Date(wall),
+        kind: monoDelta < wallDelta / 2 ? "asleep" : "clock-forward"
+      };
+      this.#o.log.info("scheduler observed a clock gap", {
+        "namzu.schedule.gap_ms": wallDelta - monoDelta,
+        "namzu.schedule.gap_kind": this.#observedGap.kind
+      });
+    } else if (monoDelta - wallDelta > GAP_MS) {
+      this.#observedGap = {
+        from: new Date(this.#lastWall),
+        to: new Date(wall),
+        kind: "clock-backward"
+      };
+      this.#o.log.info("scheduler observed the clock going back", {
+        "namzu.schedule.gap_ms": monoDelta - wallDelta
+      });
+    }
+    this.#lastWall = wall;
+    this.#lastMono = mono;
+  }
+  /** One pass: every job evaluated, the queue dispatched. Public for tests. */
+  tick() {
+    return this.#serializeState(() => this.#tick());
+  }
+  #serializeState(operation) {
+    const result = this.#stateTail.then(operation);
+    this.#stateTail = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+  async #tick() {
+    this.#observeClock();
+    if (!this.#draining && this.#o.fingerprint() !== this.#startFingerprint) {
+      this.#o.log.info("installed CLI changed; draining for a restart", {
+        "namzu.schedule.epoch": this.#o.epoch
+      });
+      this.#draining = true;
+      this.#persistManual();
+    }
+    const now = this.#now();
+    const { jobs, errors } = listJobs(this.#o.paths);
+    for (const error of errors) {
+      this.#o.log.warn("scheduled job file unreadable", {
+        "namzu.schedule.path": error.path,
+        "exception.message": error.message
+      });
+    }
+    for (const job of jobs) {
+      try {
+        await this.#tickJob(job, now);
+      } catch (error) {
+        this.#o.log.error("scheduled job evaluation failed", {
+          "namzu.schedule.job_id": job.id,
+          "exception.message": error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    this.#observedGap = void 0;
+    if (!this.#draining) await this.#dispatch(now);
+    if (this.#draining) this.#persistManual();
+    if (now - this.#lastHousekeeping > HOUSEKEEPING_MS) {
+      this.#lastHousekeeping = now;
+      for (const job of jobs) {
+        try {
+          compactHistory(this.#o.paths, job.id, now);
+          pruneClaims(this.#o.paths, job.id, job.catchUp.windowMs + CLAIM_RETENTION_EXTRA_MS, now);
+        } catch {
+        }
+      }
+      pruneDaemonLogs(this.#o.paths.daemonLog, new Date(now));
+    }
+    this.#heartbeat();
+  }
+  async #notice(kind, job, extra) {
+    if (!this.#o.notifications) return;
+    const flags = job.notify;
+    const wanted = kind === "finished" ? flags.finished : kind === "awaiting-approval" ? flags.awaitingApproval : kind === "catch-up" ? flags.finished : flags.failed || kind === "held" || kind === "needs-confirmation";
+    if (!wanted) return;
+    const always = kind === "held" || kind === "needs-confirmation" || kind === "auto-paused" || kind === "awaiting-approval" || kind === "approval-expired";
+    if (!always && !admitNotification(join4(this.#o.paths.daemon, "notify.json"), job.id, this.#now()))
+      return;
+    const text = noticeText(kind, job, extra);
+    await this.#o.notify({ jobId: job.id, ...text });
+    this.#o.log.info("scheduled run notification", {
+      "namzu.schedule.job_id": job.id,
+      "namzu.schedule.notice": kind
+    });
+  }
+  async #tickJob(loaded, now) {
+    const paths = this.#o.paths;
+    let job = loaded;
+    let state = readState(paths, job.id);
+    if (job.state === "active" && !confirmationHolds(job)) {
+      job = updateJob(paths, job.id, job.revision, (j) => ({ ...j, state: "pending-confirmation" }));
+      appendHistory(paths, job.id, {
+        v: 1,
+        kind: "job",
+        at: new Date(now).toISOString(),
+        action: "tampered",
+        by: "daemon",
+        detail: "the job file changed outside namzu; it waits for confirmation"
+      });
+      state = { ...state, lastHoldNotice: jobSecurityDigest(job) };
+      writeState(paths, state);
+      await this.#notice("held", job, { at: new Date(now) });
+    } else if (job.state === "pending-confirmation") {
+      const digest = jobSecurityDigest(job);
+      if (state.lastHoldNotice !== digest) {
+        state = { ...state, lastHoldNotice: digest };
+        writeState(paths, state);
+        await this.#notice("needs-confirmation", job, { at: new Date(now) });
+      }
+    }
+    state = await this.#reconcile(job, state, now);
+    job = readJob(paths, job.id) ?? job;
+    state = await this.#deliverPending(job, state);
+    if (this.#draining) return;
+    const evaluationState = {
+      ...state.lastEvaluatedAt ? { lastEvaluatedAt: state.lastEvaluatedAt } : {},
+      ...state.jobRevision !== void 0 ? { jobRevision: state.jobRevision } : {},
+      ...state.activeRun ? { activeRun: { status: state.activeRun.status } } : state.queued || this.#manual.some((m) => m.jobId === job.id) ? { activeRun: { status: "queued" } } : {},
+      ...state.quotaHoldUntil ? { quotaHoldUntil: state.quotaHoldUntil } : {}
+    };
+    const decision = evaluateJob({
+      job: {
+        spec: job.schedule,
+        state: job.state,
+        catchUp: job.catchUp,
+        createdAt: job.createdAt,
+        updatedAt: job.updatedAt,
+        revision: job.revision
+      },
+      state: evaluationState,
+      now: new Date(now),
+      daemon: {
+        startedAt: new Date(this.#startedAt),
+        ...this.#observedGap ? { observedGap: this.#observedGap } : {}
+      },
+      isClaimed: /* @__PURE__ */ __name((key) => isClaimed(paths, job.id, key), "isClaimed")
+    });
+    const at = new Date(now).toISOString();
+    for (const skip of decision.skip) {
+      appendHistory(paths, job.id, {
+        v: 1,
+        kind: "skip",
+        at,
+        scheduledFor: skip.scheduledFor.toISOString(),
+        reason: skip.reason,
+        count: skip.count
+      });
+    }
+    if (decision.missed) {
+      appendHistory(paths, job.id, {
+        v: 1,
+        kind: "missed",
+        at,
+        from: decision.missed.from.toISOString(),
+        to: decision.missed.to.toISOString(),
+        count: decision.missed.count,
+        ...decision.missed.capped ? { capped: true } : {},
+        reason: decision.missed.reason,
+        ...decision.fire ? { caughtUpBy: decision.fire.key } : {}
+      });
+    }
+    let next = withoutUndefined({
+      ...state,
+      lastEvaluatedAt: decision.nextState.lastEvaluatedAt.toISOString(),
+      jobRevision: decision.nextState.jobRevision,
+      nextFireAt: decision.nextState.nextFireAt?.toISOString(),
+      quotaHoldUntil: state.quotaHoldUntil && Date.parse(state.quotaHoldUntil) > now ? state.quotaHoldUntil : void 0
+    });
+    if (decision.fire) {
+      next = {
+        ...next,
+        queued: {
+          key: decision.fire.key,
+          scheduledFor: decision.fire.scheduledFor.toISOString(),
+          trigger: decision.fire.trigger,
+          queuedAt: at
+        }
+      };
+      if (decision.fire.trigger === "catch-up") {
+        await this.#notice("catch-up", job, {
+          at: new Date(now),
+          scheduledFor: decision.fire.scheduledFor,
+          ...decision.missed ? { missed: decision.missed.count } : {}
+        });
+      }
+    }
+    writeState(paths, next);
+    if (decision.jobTransition && decision.jobTransition !== job.state) {
+      const transition = decision.jobTransition;
+      if (transition === "expired" || !decision.fire) {
+        updateJob(paths, job.id, job.revision, (j) => ({ ...j, state: transition }));
+        appendHistory(paths, job.id, { v: 1, kind: "job", at, action: transition, by: "daemon" });
+      }
+    }
+  }
+  /**
+   * Record how a run this daemon did not start has ended — a foreground
+   * `schedule run-now` — exactly as a run it started is recorded. False,
+   * and nothing written, when the job's state no longer names that run (a
+   * daemon that adopted it recorded it first).
+   */
+  async finalizeRun(jobId, runId, result) {
+    const recorded = await this.#serializeState(async () => {
+      const job = readJob(this.#o.paths, jobId);
+      const run = readState(this.#o.paths, jobId).activeRun;
+      if (!job || run?.runId !== runId) return false;
+      this.#finalize(job, run, result, this.#now());
+      await this.#deliverPending(job, readState(this.#o.paths, job.id));
+      return true;
+    });
+    await this.settled();
+    return recorded;
+  }
+  /**
+   * Settle the job's run in progress if its process is gone, as a tick
+   * would, without evaluating the schedule. For a foreground `run-now`
+   * finding a run no scheduler is left to settle.
+   */
+  async reconcileJob(jobId) {
+    const state = await this.#serializeState(async () => {
+      const job = readJob(this.#o.paths, jobId);
+      if (!job) return void 0;
+      const reconciled = await this.#reconcile(job, readState(this.#o.paths, jobId), this.#now());
+      return this.#deliverPending(job, reconciled);
+    });
+    await this.settled();
+    return state;
+  }
+  /** Retry durable source deliveries after a busy source turn or daemon restart. */
+  async #deliverPending(job, state) {
+    const pending = state.deliveryPending ?? [];
+    if (pending.length === 0) return state;
+    const handled = /* @__PURE__ */ new Set();
+    for (const item of pending.slice(0, 20)) {
+      const waived = Boolean(
+        item.delivery && !job.delivery && confirmationHolds(job) && job.deliveryWaiverRunIds?.includes(item.result.runId)
+      );
+      const outcome = waived ? { kind: "quiet" } : item.delivery ? await deliverRunToSource(
+        this.#o.paths,
+        { ...job, delivery: item.delivery },
+        item.result
+      ) : { kind: "quiet" };
+      if (outcome.kind === "retry") continue;
+      if (outcome.kind === "rejected") {
+        const latest2 = readState(this.#o.paths, job.id);
+        const key = pendingResultKey(item);
+        if (latest2.lastDeliveryIssue?.key !== key) {
+          this.#o.log.warn("scheduled result could not reach its source conversation", {
+            "namzu.schedule.job_id": job.id,
+            "namzu.schedule.run_id": item.result.runId,
+            "exception.message": outcome.reason
+          });
+          writeState(this.#o.paths, {
+            ...latest2,
+            lastDeliveryIssue: { key, reason: outcome.reason }
+          });
+        }
+        continue;
+      }
+      const nextState = item.result.scriptReport?.nextState;
+      if (nextState !== void 0) {
+        const revision = item.result.scriptStateRevision;
+        if (revision === void 0) {
+          this.#o.log.error("scheduled script state revision is missing", {
+            "namzu.schedule.job_id": job.id,
+            "namzu.schedule.run_id": item.result.runId
+          });
+          continue;
+        }
+        try {
+          const written = writeScriptState(
+            this.#o.paths,
+            job.id,
+            revision,
+            item.result.runId,
+            nextState
+          );
+          if (written.kind === "conflict") {
+            this.#o.log.error("scheduled script state changed before its result settled", {
+              "namzu.schedule.job_id": job.id,
+              "namzu.schedule.run_id": item.result.runId
+            });
+            continue;
+          }
+        } catch (error) {
+          this.#o.log.error("scheduled script state could not be saved", {
+            "namzu.schedule.job_id": job.id,
+            "namzu.schedule.run_id": item.result.runId,
+            "exception.message": error instanceof Error ? error.message : String(error)
+          });
+          continue;
+        }
+      }
+      if (waived && !readHistory(this.#o.paths, job.id).some(
+        (record) => record.kind === "job" && record.action === "delivery-waived" && record.detail === item.result.runId
+      )) {
+        appendHistory(this.#o.paths, job.id, {
+          v: 1,
+          kind: "job",
+          at: new Date(this.#now()).toISOString(),
+          action: "delivery-waived",
+          by: "operator",
+          detail: item.result.runId
+        });
+      }
+      handled.add(pendingResultKey(item));
+    }
+    if (handled.size === 0) return readState(this.#o.paths, job.id);
+    const latest = readState(this.#o.paths, job.id);
+    const remaining = (latest.deliveryPending ?? []).filter(
+      (item) => !handled.has(pendingResultKey(item))
+    );
+    const next = withoutUndefined({
+      ...latest,
+      deliveryPending: remaining.length > 0 ? remaining : void 0,
+      lastDeliveryIssue: latest.lastDeliveryIssue && handled.has(latest.lastDeliveryIssue.key) ? void 0 : latest.lastDeliveryIssue
+    });
+    writeState(this.#o.paths, next);
+    return next;
+  }
+  /** Finalise or adopt the job's run in progress, if it has one. */
+  async #reconcile(job, state, now) {
+    for (const [runId, tracked2] of this.#running) {
+      if (tracked2.jobId === job.id && !tracked2.run && state.activeRun?.runId !== runId)
+        this.#running.delete(runId);
+    }
+    const run = state.activeRun;
+    if (!run) return state;
+    const tracked = this.#running.get(run.runId);
+    if (tracked?.run) return state;
+    const result = readRunResult(this.#o.paths, job.id, run.runId);
+    if (run.status === "running") {
+      if (isFinal(result)) return this.#finalize(job, run, result, now);
+      const slug = result?.projectSlug ?? run.projectSlug;
+      const sessionId = result?.sessionId ?? run.sessionId;
+      const ref2 = slug && sessionId ? { home: this.#o.paths.home, projectSlug: slug, sessionId } : void 0;
+      if (ref2 && await sessionLeaseLive(ref2, now)) {
+        this.#running.set(run.runId, {
+          jobId: job.id,
+          runId: run.runId,
+          folder: job.folder.canonical,
+          writes: allowsWrites(job.permissions)
+        });
+        return state;
+      }
+      if (!ref2 && now - Date.parse(run.startedAt) < (run.noSessionGraceMs ?? noSessionStartGraceMs(job))) {
+        this.#running.set(run.runId, {
+          jobId: job.id,
+          runId: run.runId,
+          folder: job.folder.canonical,
+          writes: allowsWrites(job.permissions)
+        });
+        return state;
+      }
+      this.#running.delete(run.runId);
+      const facts2 = ref2 ? await sessionFacts(ref2) : null;
+      if (facts2?.activeTurn?.paused) {
+        return this.#finalize(
+          job,
+          run,
+          {
+            ...result ?? this.#emptyResult(job, run),
+            status: "awaiting-approval",
+            exitCode: 0,
+            turnId: facts2.activeTurn.turnId,
+            ...ref2 ? { sessionId: ref2.sessionId, projectSlug: ref2.projectSlug } : {}
+          },
+          now
+        );
+      }
+      const outcome2 = facts2 && !facts2.activeTurn ? turnOutcome(facts2, run.turnId ?? result?.turnId) : void 0;
+      return this.#finalize(
+        job,
+        run,
+        {
+          ...result ?? this.#emptyResult(job, run),
+          status: outcome2?.status ?? "interrupted",
+          exitCode: outcome2?.status === "completed" ? 0 : 1,
+          reason: outcome2?.reason ?? "the run stopped without recording a result (its process ended)"
+        },
+        now
+      );
+    }
+    if (!run.sessionId || !run.projectSlug) {
+      return this.#finalize(
+        job,
+        run,
+        { ...this.#emptyResult(job, run), status: "interrupted", exitCode: 1 },
+        now
+      );
+    }
+    const ref = { home: this.#o.paths.home, projectSlug: run.projectSlug, sessionId: run.sessionId };
+    const facts = await sessionFacts(ref);
+    if (!facts) {
+      return this.#finalize(
+        job,
+        run,
+        {
+          ...this.#emptyResult(job, run),
+          status: "interrupted",
+          exitCode: 1,
+          reason: "the parked session is gone"
+        },
+        now
+      );
+    }
+    const active = facts.activeTurn;
+    if (active && active.turnId === run.turnId) {
+      if (!active.paused) return state;
+      const parkedAt = Date.parse(run.parkedAt ?? run.startedAt);
+      if (now - parkedAt > job.approvalTtlMs && !await sessionLeaseLive(ref, now)) {
+        try {
+          await abandonParkedTurn(ref, active.turnId, "Scheduled run: approval expired");
+        } catch (error) {
+          this.#o.log.warn("could not abandon an expired park", {
+            "namzu.schedule.job_id": job.id,
+            "exception.message": error instanceof Error ? error.message : String(error)
+          });
+          return state;
+        }
+        const expired = this.#finalize(
+          job,
+          run,
+          {
+            ...this.#emptyResult(job, run),
+            status: "approval-expired",
+            exitCode: 1,
+            reason: "nobody answered the approval in time; the turn was abandoned"
+          },
+          now
+        );
+        await this.#notice("approval-expired", job, { at: new Date(now) });
+        return expired;
+      }
+      return state;
+    }
+    if (active) return state;
+    const outcome = turnOutcome(facts, run.turnId);
+    if (!outcome) return state;
+    return this.#finalize(
+      job,
+      run,
+      {
+        ...this.#emptyResult(job, run),
+        status: outcome.status,
+        exitCode: outcome.status === "completed" ? 0 : 1,
+        ...outcome.reason ? { reason: outcome.reason } : {}
+      },
+      now
+    );
+  }
+  #emptyResult(job, run) {
+    return {
+      v: 1,
+      kind: "schedule-run-result",
+      runId: run.runId,
+      jobId: job.id,
+      status: "interrupted",
+      exitCode: 1,
+      startedAt: run.startedAt,
+      ...run.sessionId ? { sessionId: run.sessionId } : {},
+      ...run.projectSlug ? { projectSlug: run.projectSlug } : {},
+      ...run.turnId ? { turnId: run.turnId } : {}
+    };
+  }
+  /** Record how a run ended, update counters, notify. Returns the new state (already written). */
+  #finalize(job, run, result, now) {
+    const paths = this.#o.paths;
+    const at = new Date(now).toISOString();
+    const status = result.status === "running" ? "interrupted" : result.status;
+    this.#running.delete(run.runId);
+    appendRunRecord(paths, job.id, run, result, at);
+    const current = readState(paths, job.id);
+    const failed = status === "failed" || status === "blocked-config" || status === "timed-out" || status === "interrupted" || status === "approval-expired" || status === "check-failed";
+    const counters = {
+      runs: current.counters.runs + (status === "awaiting-approval" ? 0 : 1),
+      failures: current.counters.failures + (failed ? 1 : 0),
+      failureStreak: failed ? current.counters.failureStreak + 1 : status === "completed" ? 0 : current.counters.failureStreak
+    };
+    const quotaHold = status === "failed" && result.retryAfterMs !== void 0 && result.retryAfterMs > job.budget.waitForProviderMs ? new Date(now + result.retryAfterMs).toISOString() : current.quotaHoldUntil;
+    let next;
+    if (status === "awaiting-approval") {
+      next = withoutUndefined({
+        ...current,
+        counters,
+        activeRun: withoutUndefined({
+          ...run,
+          status: "awaiting-approval",
+          sessionId: result.sessionId ?? run.sessionId,
+          projectSlug: result.projectSlug ?? run.projectSlug,
+          turnId: result.turnId ?? run.turnId,
+          parkedAt: run.parkedAt ?? at,
+          handoff: result.handoff ? { reason: result.handoff.reason } : void 0
+        })
+      });
+    } else {
+      next = withoutUndefined({
+        ...current,
+        counters,
+        activeRun: void 0,
+        quotaHoldUntil: quotaHold,
+        lastRun: withoutUndefined({
+          runId: run.runId,
+          scheduledFor: run.scheduledFor,
+          status,
+          endedAt: result.endedAt ?? at,
+          sessionId: result.sessionId,
+          refusedCalls: result.refusedCalls?.count,
+          failedCalls: result.failedCalls?.count
+        })
+      });
+    }
+    if (run.delivery || result.scriptReport?.nextState !== void 0) {
+      const snapshot = {
+        ...result,
+        status,
+        endedAt: result.endedAt ?? at
+      };
+      next = {
+        ...next,
+        deliveryPending: [
+          ...current.deliveryPending ?? [],
+          { result: snapshot, ...run.delivery ? { delivery: run.delivery } : {} }
+        ]
+      };
+    }
+    let incident = next.lastIncident;
+    let tell;
+    if (status === "completed") {
+      incident = void 0;
+      if (result.scriptReport?.state !== "quiet") tell = "finished";
+    } else if (status === "awaiting-approval") {
+      tell = "awaiting-approval";
+    } else if (failed && status !== "approval-expired") {
+      const signature = failureSignature(status, result.reason);
+      if (incident?.signature !== signature) {
+        tell = status === "blocked-config" ? "blocked-config" : status === "timed-out" ? "timed-out" : status === "interrupted" ? "interrupted" : status === "check-failed" ? "check-failed" : "failed";
+        incident = { signature, at };
+      }
+    }
+    next = withoutUndefined({ ...next, lastIncident: incident });
+    writeState(paths, next);
+    const pauseAfter = job.failurePolicy.pauseAfterFailures;
+    let autoPaused = false;
+    if (failed && pauseAfter > 0 && counters.failureStreak >= pauseAfter) {
+      const latest = readJob(paths, job.id);
+      if (latest && latest.state === "active") {
+        updateJob(paths, job.id, latest.revision, (j) => ({
+          ...j,
+          state: "paused",
+          pausedAt: at,
+          pausedBy: "auto-failure-streak"
+        }));
+        appendHistory(paths, job.id, {
+          v: 1,
+          kind: "job",
+          at,
+          action: "paused",
+          by: "auto-failure-streak",
+          detail: `${counters.failureStreak} failed runs in a row`
+        });
+        autoPaused = true;
+      }
+    }
+    if (job.schedule.kind === "at" && status !== "awaiting-approval" && run.trigger !== "manual") {
+      const latest = readJob(paths, job.id);
+      if (latest && latest.state === "active") {
+        updateJob(paths, job.id, latest.revision, (j) => ({ ...j, state: "completed" }));
+        appendHistory(paths, job.id, { v: 1, kind: "job", at, action: "completed", by: "daemon" });
+      }
+    }
+    const notices = [];
+    if (tell) {
+      const summary = result.summary ?? scriptSummaryOf(result);
+      notices.push(
+        this.#notice(tell, job, {
+          at: new Date(now),
+          ...summary ? { summary } : {},
+          ...result.refusedCalls ? { refused: result.refusedCalls } : {},
+          ...tell === "check-failed" && result.reason ? { reason: result.reason } : {},
+          ...tell === "awaiting-approval" && next.activeRun?.sessionId ? { resumeCommand: resumeCommand(job, next.activeRun.sessionId) } : {},
+          ...tell === "awaiting-approval" && result.handoff ? { handoff: result.handoff.reason } : {}
+        })
+      );
+    }
+    if (autoPaused)
+      notices.push(
+        this.#notice("auto-paused", job, { at: new Date(now), failures: counters.failureStreak })
+      );
+    if (status === "completed") {
+      notices.push(
+        archiveOldRuns(paths, job, next).then(
+          (archived) => {
+            if (archived.length > 0) {
+              const latest = readState(paths, job.id);
+              writeState(paths, {
+                ...latest,
+                archivedSessions: [...latest.archivedSessions ?? [], ...archived].slice(-200)
+              });
+            }
+          },
+          () => void 0
+        )
+      );
+    }
+    this.#finalizing.push(Promise.allSettled(notices).then(() => void 0));
+    this.#o.log.info("scheduled run recorded", {
+      "namzu.schedule.job_id": job.id,
+      "namzu.schedule.run_id": run.runId,
+      "namzu.schedule.status": status
+    });
+    return next;
+  }
+  /** Start queued runs, oldest first, within the cap and the folder lanes. */
+  async #dispatch(now) {
+    const paths = this.#o.paths;
+    const queue = [];
+    for (const job of listJobs(paths).jobs) {
+      const state = readState(paths, job.id);
+      if (state.queued) queue.push({ job, state });
+    }
+    queue.sort(
+      (a, b) => (a.state.queued?.queuedAt ?? "").localeCompare(b.state.queued?.queuedAt ?? "")
+    );
+    for (const manual of this.#manual.splice(0)) {
+      const job = readJob(paths, manual.jobId);
+      if (job) queue.push({ job, state: readState(paths, job.id), manual: manual.runId });
+    }
+    for (const entry of queue) {
+      const { job } = entry;
+      const queued = entry.state.queued;
+      if (!await this.#stillOwner()) {
+        this.#o.log.warn("scheduler fenced out; not dispatching", {
+          "namzu.schedule.epoch": this.#o.epoch
+        });
+        return;
+      }
+      const latest = readJob(paths, job.id);
+      if (!latest || latest.state !== "active" || !confirmationHolds(latest)) {
+        if (queued) writeState(paths, withoutUndefined({ ...entry.state, queued: void 0 }));
+        continue;
+      }
+      if (readState(paths, job.id).deliveryPending?.length) {
+        if (entry.manual) this.#manual.push({ jobId: job.id, runId: entry.manual });
+        continue;
+      }
+      const writes = allowsWrites(latest.permissions);
+      const busyLane = writes && [...this.#running.values()].some((t) => t.writes && t.folder === latest.folder.canonical);
+      if (this.#running.size >= this.#o.maxConcurrentRuns || busyLane) {
+        this.#delayReasons.set(job.id, busyLane ? "folder-busy" : "concurrency-cap");
+        if (entry.manual) this.#manual.push({ jobId: job.id, runId: entry.manual });
+        continue;
+      }
+      const delayReason = this.#delayReasons.get(job.id);
+      this.#delayReasons.delete(job.id);
+      const queuedManual = !entry.manual && queued?.trigger === "manual" && queued.key.startsWith(MANUAL_KEY_PREFIX) ? queued.key.slice(MANUAL_KEY_PREFIX.length) : void 0;
+      const runId = entry.manual ?? queuedManual ?? generateScheduleRunId();
+      const key = entry.manual ? `${MANUAL_KEY_PREFIX}${runId}` : queued?.key;
+      const trigger = entry.manual ? "manual" : queued?.trigger ?? "scheduled";
+      if (!claimOccurrence(paths, {
+        jobId: job.id,
+        key,
+        runId,
+        daemonEpoch: this.#o.epoch,
+        at: new Date(now).toISOString()
+      })) {
+        if (queued)
+          writeState(paths, withoutUndefined({ ...readState(paths, job.id), queued: void 0 }));
+        continue;
+      }
+      const delayedMs = queued && trigger !== "manual" ? Math.max(0, now - Date.parse(queued.queuedAt)) : 0;
+      const run = withoutUndefined({
+        runId,
+        key,
+        trigger,
+        scheduledFor: trigger === "manual" ? void 0 : queued?.scheduledFor,
+        startedAt: new Date(now).toISOString(),
+        daemonEpoch: this.#o.epoch,
+        status: "running",
+        noSessionGraceMs: noSessionStartGraceMs(latest),
+        delivery: latest.delivery,
+        delayedMs: delayedMs >= 1e3 ? delayedMs : void 0,
+        delayReason: delayedMs >= 1e3 ? delayReason ?? "concurrency-cap" : void 0
+      });
+      writeState(
+        paths,
+        withoutUndefined({ ...readState(paths, job.id), queued: void 0, activeRun: run })
+      );
+      appendHistory(paths, job.id, {
+        v: 1,
+        kind: "run",
+        at: run.startedAt,
+        runId,
+        key,
+        trigger,
+        ...run.scheduledFor ? { scheduledFor: run.scheduledFor } : {},
+        startedAt: run.startedAt,
+        ...run.delayedMs ? { delayedMs: run.delayedMs, delayReason: run.delayReason ?? "concurrency-cap" } : {},
+        status: "running"
+      });
+      let spawned;
+      try {
+        spawned = this.#o.spawnFire({
+          job: latest,
+          runId,
+          key,
+          trigger,
+          ...run.scheduledFor ? { scheduledFor: run.scheduledFor } : {},
+          epoch: this.#o.epoch
+        });
+      } catch (error) {
+        this.#finalize(
+          latest,
+          run,
+          {
+            ...this.#emptyResult(latest, run),
+            status: "failed",
+            exitCode: 1,
+            reason: `the run could not be started: ${error instanceof Error ? error.message : String(error)}`
+          },
+          now
+        );
+        continue;
+      }
+      this.#running.set(runId, {
+        jobId: job.id,
+        runId,
+        folder: latest.folder.canonical,
+        writes,
+        run: spawned
+      });
+      this.#o.log.info("scheduled run started", {
+        "namzu.schedule.job_id": job.id,
+        "namzu.schedule.run_id": runId,
+        "namzu.schedule.trigger": trigger
+      });
+      void spawned.exited.then(
+        () => this.#serializeState(() => {
+          const tracked = this.#running.get(runId);
+          if (tracked) this.#running.set(runId, { ...tracked, run: void 0 });
+          const jobNow = readJob(paths, job.id) ?? latest;
+          const state = readState(paths, job.id);
+          if (state.activeRun?.runId === runId) {
+            const result = readRunResult(paths, job.id, runId);
+            this.#finalize(
+              jobNow,
+              state.activeRun,
+              isFinal(result) ? result : {
+                ...this.#emptyResult(jobNow, state.activeRun),
+                ...result ?? {},
+                status: "interrupted",
+                exitCode: 1,
+                reason: "the run ended without recording a result"
+              },
+              this.#now()
+            );
+          } else {
+            this.#running.delete(runId);
+            if (!readJob(paths, job.id)) {
+              const result = readRunResult(paths, job.id, runId);
+              appendRunRecord(
+                paths,
+                job.id,
+                run,
+                isFinal(result) ? result : {
+                  ...this.#emptyResult(latest, run),
+                  ...result ?? {},
+                  status: "interrupted",
+                  exitCode: 1,
+                  reason: "the run ended without recording a result"
+                },
+                new Date(this.#now()).toISOString()
+              );
+            }
+          }
+          this.wake();
+        })
+      ).catch((error) => {
+        this.#o.log.error("scheduled run exit could not be recorded", {
+          "namzu.schedule.job_id": job.id,
+          "namzu.schedule.run_id": runId,
+          "exception.message": error instanceof Error ? error.message : String(error)
+        });
+        this.wake();
+      });
+    }
+  }
+  /** For tests: wait until notifications and archiving started by finalisation are done. */
+  async settled() {
+    await this.#stateTail;
+    await Promise.allSettled(this.#finalizing.splice(0));
+  }
+};
+var MANUAL_KEY_PREFIX = "manual-";
+function appendRunRecord(paths, jobId, run, result, at) {
+  const status = result.status === "running" ? "interrupted" : result.status;
+  appendHistory(paths, jobId, {
+    v: runResultVersion({
+      status,
+      gateResult: result.gateResult,
+      scriptOutput: result.scriptOutput
+    }),
+    kind: "run",
+    at,
+    runId: run.runId,
+    key: run.key,
+    trigger: run.trigger,
+    ...run.scheduledFor ? { scheduledFor: run.scheduledFor } : {},
+    startedAt: run.startedAt,
+    ...status === "awaiting-approval" ? {} : { endedAt: result.endedAt ?? at },
+    ...run.delayedMs ? { delayedMs: run.delayedMs, delayReason: run.delayReason ?? "concurrency-cap" } : {},
+    ...result.sessionId ? { sessionId: result.sessionId } : {},
+    status,
+    ...result.reason ? { reason: result.reason } : {},
+    exitCode: result.exitCode,
+    ...result.summary ? { summary: result.summary } : {},
+    ...result.usage ? { usage: result.usage } : {},
+    ...result.warnings ? { warnings: result.warnings } : {},
+    ...result.refusedCalls ? { refusedCalls: result.refusedCalls } : {},
+    ...result.failedCalls ? { failedCalls: result.failedCalls } : {},
+    ...result.gateResult ? { gateResult: result.gateResult } : {},
+    ...result.scriptOutput ? { scriptOutput: result.scriptOutput } : {}
+  });
+}
+__name(appendRunRecord, "appendRunRecord");
+function stopRequestPath(paths) {
+  return join4(paths.daemon, "stop.json");
+}
+__name(stopRequestPath, "stopRequestPath");
+function requestStop(paths, stop) {
+  if (stop)
+    writeJsonAtomic(stopRequestPath(paths), {
+      v: 1,
+      kind: "schedule-stop",
+      at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  else rmSync3(stopRequestPath(paths), { force: true });
+}
+__name(requestStop, "requestStop");
+function spawnFireProcess(options) {
+  return (request) => {
+    const logPath = options.paths.runLog(request.job.id, request.runId);
+    ensureDir(dirname(logPath));
+    writeFileSync(logPath, "", { flag: "a", mode: PRIVATE_FILE_MODE });
+    const fd = openSync(logPath, "a", PRIVATE_FILE_MODE);
+    let child;
+    try {
+      child = spawn(
+        options.node,
+        [
+          options.bin,
+          "schedule",
+          "__fire",
+          "--home",
+          options.paths.home,
+          "--job",
+          request.job.id,
+          "--run",
+          request.runId,
+          "--key",
+          request.key,
+          "--revision",
+          String(request.job.revision),
+          "--trigger",
+          request.trigger,
+          ...request.scheduledFor ? ["--scheduled-for", request.scheduledFor] : [],
+          "--epoch",
+          request.epoch
+        ],
+        {
+          cwd: request.job.folder.canonical,
+          env: childEnvironment(options.env, options.paths.home),
+          stdio: ["ignore", fd, fd],
+          detached: process.platform !== "win32",
+          windowsHide: true
+        }
+      );
+    } finally {
+      closeSync(fd);
+    }
+    const exited = new Promise((resolve) => {
+      child.once("exit", (code) => resolve(code));
+      child.once("error", () => resolve(null));
+    });
+    child.unref();
+    return {
+      exited,
+      terminate: /* @__PURE__ */ __name(() => {
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+      }, "terminate")
+    };
+  };
+}
+__name(spawnFireProcess, "spawnFireProcess");
+function installedFingerprint(bin) {
+  const dist = dirname(bin);
+  const watched = [
+    join4(dist, "..", "package.json"),
+    bin,
+    join4(dist, "schedule", "daemon", "daemon.js"),
+    join4(dist, "schedule", "fire", "fire.js")
+  ];
+  return () => {
+    const parts = [];
+    for (const path of watched) {
+      try {
+        const st = statSync4(path);
+        parts.push(`${st.size}:${st.mtimeMs}`);
+      } catch {
+        parts.push("missing");
+      }
+    }
+    return parts.join("|");
+  };
+}
+__name(installedFingerprint, "installedFingerprint");
+
+// src/schedule/fire/browser-preflight.ts
+import { existsSync as existsSync2 } from "node:fs";
+async function browserPreflight(grant, home, deps) {
+  let browser;
+  try {
+    browser = await (deps.load ?? (() => import("@namzu/browser")))();
+  } catch (error) {
+    return {
+      ok: false,
+      reason: `the job uses the browser, but @namzu/browser cannot be loaded (${error instanceof Error ? error.message : String(error)}); run namzu doctor`
+    };
+  }
+  const login = `namzu browser login ${grant.profile} ${Object.keys(grant.sites)[0] ?? "<url>"}`;
+  let descriptor;
+  try {
+    descriptor = new browser.BrowserProfileStore(home).get(grant.profile);
+  } catch (error) {
+    return {
+      ok: false,
+      reason: `browser profile ${grant.profile} cannot be read: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  if (!descriptor) {
+    return {
+      ok: false,
+      reason: `browser profile ${grant.profile} does not exist; sign in once with ${login}`
+    };
+  }
+  const engine = descriptor.engine === "windows-cdp" ? "windows" : "local";
+  const plan = browser.runnableBrowserPlan(
+    browser.detectBrowserEnvironment(
+      deps.env,
+      deps.platform ?? process.platform,
+      deps.probes ?? browser.nodeBrowserProbes,
+      { engine, headless: grant.headed ? "never" : "always", mode: "unattended" }
+    )
+  );
+  if (plan.unavailableReason !== void 0) {
+    return {
+      ok: false,
+      reason: `the browser for profile ${grant.profile} cannot start here: ${plan.unavailableReason}`
+    };
+  }
+  if (plan.engine !== descriptor.engine) {
+    return {
+      ok: false,
+      reason: `browser profile ${grant.profile} was signed in with ${descriptor.engine === "windows-cdp" ? "the Windows browser" : "a browser inside Linux"}, and this run would use ${plan.engine === "windows-cdp" ? "the Windows browser" : "a browser inside Linux"}`
+    };
+  }
+  const exists = deps.exists ?? existsSync2;
+  const dataDir = plan.engine === "windows-cdp" ? browser.windowsPathToWsl(descriptor.userDataDir, plan.mountRoot) : descriptor.userDataDir;
+  if (dataDir === void 0 || !exists(dataDir)) {
+    return {
+      ok: false,
+      reason: `browser profile ${grant.profile} has no data at ${descriptor.userDataDir}; sign in again with ${login}`
+    };
+  }
+  return { ok: true, engine, warnings: plan.warnings };
+}
+__name(browserPreflight, "browserPreflight");
+
+// src/schedule/fire/run-script.ts
+import { constants, accessSync } from "node:fs";
+var MAX_SCRIPT_OUTPUT_CHARS = 8e3;
+function capOutput(text, max = MAX_SCRIPT_OUTPUT_CHARS) {
+  return text.length <= max ? text : `${text.slice(0, max)}
+...(truncated)`;
+}
+__name(capOutput, "capOutput");
+function isExecutable(path) {
+  try {
+    accessSync(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isExecutable, "isExecutable");
+async function runScript(body, shell, options) {
+  const selected = options.resolvedShell ?? installedCommandShellForDialect(shell);
+  if (!selected) {
+    return { stdout: "", stderr: "", exitCode: null, timedOut: false, shellUnavailable: shell };
+  }
+  if (selected.dialect !== shell) {
+    return {
+      stdout: "",
+      stderr: "",
+      exitCode: null,
+      timedOut: false,
+      dialectMismatch: { expected: shell, actual: selected.dialect }
+    };
+  }
+  try {
+    const { stdout, stderr } = await execHostShell(body, {
+      cwd: options.cwd,
+      env: options.env,
+      timeout: options.timeoutMs,
+      maxBuffer: options.maxOutputBytes ?? 10 * 1024 * 1024,
+      shell: selected,
+      ...options.onOutput ? { onOutput: options.onOutput } : {}
+    });
+    return { stdout, stderr, exitCode: 0, timedOut: false };
+  } catch (error) {
+    const failure = error;
+    if ((failure.code === "ENOENT" || failure.code === "EACCES") && selected.path !== void 0 && !isExecutable(selected.path)) {
+      return {
+        stdout: failure.stdout ?? "",
+        stderr: failure.stderr ?? "",
+        exitCode: null,
+        timedOut: false,
+        shellUnavailable: shell
+      };
+    }
+    return {
+      stdout: failure.stdout ?? "",
+      stderr: failure.stderr ?? (failure.message ? `${failure.message}
+` : ""),
+      exitCode: typeof failure.code === "number" ? failure.code : null,
+      timedOut: failure.timedOut === true
+    };
+  }
+}
+__name(runScript, "runScript");
+
+// src/schedule/fire/wake-gate.ts
+function shown(text, max = 200) {
+  const cut = sanitizeLine(text, max);
+  return cut.includes("`") ? `\`\` ${cut} \`\`` : `\`${cut}\``;
+}
+__name(shown, "shown");
+function isJson(line) {
+  try {
+    JSON.parse(line);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isJson, "isJson");
+function parseWakeGateOutput(stdout, maxContextChars) {
+  const lines = stdout.split(/\r?\n/);
+  while (lines.length > 0 && lines.at(-1).trim() === "") lines.pop();
+  if (lines.length === 0) {
+    return {
+      ok: false,
+      reason: 'the wake-gate script produced no output; it must print exactly one JSON line, {"wake": boolean, "context": string}'
+    };
+  }
+  const last = lines.at(-1);
+  if (!isJson(last)) {
+    return {
+      ok: false,
+      reason: `the wake-gate script\u2019s stdout does not end with JSON: ${shown(last)}`
+    };
+  }
+  const earlierJsonLines = lines.slice(0, -1).filter((line) => line.trim() !== "" && isJson(line));
+  if (earlierJsonLines.length > 0) {
+    return {
+      ok: false,
+      reason: "the wake-gate script printed more than one line of JSON stdout; it must print exactly one, as its last line"
+    };
+  }
+  const value = JSON.parse(last);
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return {
+      ok: false,
+      reason: `the wake-gate script\u2019s JSON line is not an object: ${shown(last)}`
+    };
+  }
+  const record = value;
+  if (typeof record.wake !== "boolean") {
+    return {
+      ok: false,
+      reason: `the wake-gate script\u2019s JSON has no boolean "wake": ${shown(last)}`
+    };
+  }
+  if (typeof record.context !== "string") {
+    return {
+      ok: false,
+      reason: `the wake-gate script\u2019s JSON has no string "context": ${shown(last)}`
+    };
+  }
+  const context = record.context.length > maxContextChars ? `${record.context.slice(0, maxContextChars)}
+...(truncated)` : record.context;
+  return { ok: true, result: { wake: record.wake, context } };
+}
+__name(parseWakeGateOutput, "parseWakeGateOutput");
+
+// src/schedule/fire/fire.ts
+var HOLD_REASON = "Scheduled run: waiting for the operator to approve";
+var WATCHDOG_GRACE_MS = 6e4;
+function parseFireArgs(argv) {
+  const get = /* @__PURE__ */ __name((name) => {
+    const at = argv.indexOf(`--${name}`);
+    return at >= 0 ? argv[at + 1] : void 0;
+  }, "get");
+  const jobId = get("job");
+  const runId = get("run");
+  const key = get("key");
+  const revision = Number(get("revision"));
+  const trigger = get("trigger") ?? "scheduled";
+  if (!jobId || !runId || !key || !Number.isSafeInteger(revision)) {
+    return { error: "__fire needs --job, --run, --key and --revision" };
+  }
+  if (!["scheduled", "late", "catch-up", "manual"].includes(trigger)) {
+    return { error: `__fire: unknown trigger ${trigger}` };
+  }
+  const scheduledFor = get("scheduled-for");
+  const daemonEpoch = get("epoch");
+  return {
+    jobId,
+    runId,
+    key,
+    revision,
+    trigger,
+    ...scheduledFor ? { scheduledFor } : {},
+    ...daemonEpoch ? { daemonEpoch } : {}
+  };
+}
+__name(parseFireArgs, "parseFireArgs");
+function credentialSource(source) {
+  switch (source.kind) {
+    case "env":
+      return {
+        text: `environment variable ${source.envName ?? ""}`.trim(),
+        borrowed: false
+      };
+    case "claude-file":
+      return {
+        text: `Claude Code\u2019s sign-in (${source.path ?? ""})`,
+        borrowed: true
+      };
+    case "codex-file":
+      return { text: `Codex\u2019s sign-in (${source.path ?? ""})`, borrowed: true };
+    case "gemini-file":
+      return {
+        text: `Gemini CLI\u2019s sign-in (${source.path ?? ""})`,
+        borrowed: true
+      };
+    case "stored-gemini-key":
+      return {
+        text: `namzu\u2019s saved Gemini API key (${source.path ?? ""})`,
+        borrowed: false
+      };
+    case "stored-api-key":
+      return {
+        text: `namzu\u2019s saved API key (${source.path ?? ""})`,
+        borrowed: false
+      };
+    case "stored":
+      return {
+        text: `namzu\u2019s credential store (${source.path ?? ""})`,
+        borrowed: false
+      };
+    case "keychain":
+      return { text: "the system keychain", borrowed: true };
+    default:
+      return { text: source.kind, borrowed: false };
+  }
+}
+__name(credentialSource, "credentialSource");
+var BORROWED_CREDENTIAL_WARNING = "This run used another program\u2019s sign-in. Refreshing it here can race that program\u2019s own refresh; store a credential with `namzu login` or daemon.env for unattended runs.";
+async function runFire(ctx, paths, args, deps = {}) {
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  const startedAt = now().toISOString();
+  if (!deps.keepLogging) installCliLogging(createStderrSink("json"), "info");
+  const log = cliLogger();
+  let sessionId;
+  let projectSlug;
+  let turnId;
+  const warnings = [];
+  const found = {};
+  let calls = new CallTally();
+  let gateResult;
+  let scriptOutput;
+  const base = /* @__PURE__ */ __name(() => ({
+    v: 1,
+    kind: "schedule-run-result",
+    runId: args.runId,
+    jobId: args.jobId,
+    startedAt,
+    ...sessionId ? { sessionId } : {},
+    ...projectSlug ? { projectSlug } : {},
+    ...turnId ? { turnId } : {},
+    ...found.credential ? { credentialSource: found.credential } : {},
+    ...warnings.length > 0 ? { warnings: [...warnings] } : {},
+    ...gateResult ? { gateResult } : {},
+    ...scriptOutput ? { scriptOutput } : {},
+    ...calls.tallies()
+  }), "base");
+  let settledByWatchdog = false;
+  const finish = /* @__PURE__ */ __name((status, exitCode, extra = {}) => {
+    if (settledByWatchdog) return 1;
+    const result = {
+      ...base(),
+      status,
+      exitCode,
+      endedAt: now().toISOString(),
+      ...extra
+    };
+    writeRunResult(paths, { ...result, v: runResultVersion(result) });
+    log.info("scheduled run finished", {
+      "namzu.schedule.job_id": args.jobId,
+      "namzu.schedule.run_id": args.runId,
+      "namzu.schedule.status": status
+    });
+    return exitCode;
+  }, "finish");
+  const blocked = /* @__PURE__ */ __name((reason, exitCode = 1) => finish("blocked-config", exitCode, { reason }), "blocked");
+  writeRunResult(paths, { ...base(), status: "running", exitCode: 0 });
+  let job;
+  try {
+    job = readJob(paths, args.jobId);
+  } catch (error) {
+    return blocked(error instanceof Error ? error.message : String(error));
+  }
+  if (!job) return blocked("the job was removed before the run started");
+  if (job.revision !== args.revision) {
+    return blocked(
+      `job changed: revision ${job.revision}, the run was claimed for ${args.revision}`
+    );
+  }
+  if (job.state !== "active") return blocked(`the job is ${job.state}`);
+  if (!confirmationHolds(job)) {
+    return blocked(
+      `job changed outside namzu since it was confirmed; run namzu schedule confirm ${job.name}`
+    );
+  }
+  const runKind = job.runKind ?? "agent";
+  if (job.workspace !== void 0 && job.workspace !== "none")
+    return blocked(`the job has an unknown workspace mode: ${String(job.workspace)}`);
+  if (runKind !== "agent" && runKind !== "script" && runKind !== "script+agent") {
+    return blocked(`the job has an unknown run kind: ${String(runKind)}`);
+  }
+  if (runKind !== "agent" && !job.script) {
+    return blocked(`the ${runKind} job has no script recorded`);
+  }
+  if (job.script?.report !== void 0 && (runKind !== "script" || job.script.report !== "json-v1"))
+    return blocked("the script report mode is not valid for this job");
+  const model = job.model;
+  if (runKind !== "script" && !model)
+    return blocked("an agent job has no model; edit the job and confirm it again");
+  if (job.workspace === "none") {
+    if (runKind !== "script")
+      return blocked("a no-project workspace is only valid for a pure script job");
+    let expected;
+    try {
+      expected = plannedScratchFolder(paths.home, job.id);
+    } catch (error) {
+      return blocked(
+        `scratch folder cannot be located: ${error instanceof Error ? error.message : String(error)}`,
+        77
+      );
+    }
+    if (job.folder.path !== expected || job.folder.canonical !== expected)
+      return blocked("scratch folder differs from the job id and NAMZU_HOME", 77);
+  }
+  const folder = job.workspace === "none" ? checkScratchFolder(paths.home, job.id) : checkJobFolder(job.folder.path, { namzuHome: paths.home });
+  if (!folder.ok) return blocked(folder.reason, 77);
+  if (folder.canonical !== job.folder.canonical || job.trust?.canonical !== folder.canonical) {
+    return blocked(
+      `folder moved or replaced: ${job.folder.path} is now ${folder.canonical}, the job was confirmed for ${job.folder.canonical}`,
+      77
+    );
+  }
+  const readable = folderReadable(folder.canonical);
+  if (!readable.ok) return blocked(readable.reason);
+  const changed = job.workspace === "none" ? [] : projectDigestChanges(job.projectDigest, computeProjectDigest(folder.canonical));
+  if (changed.length > 0) {
+    return blocked(
+      `project config changed since the job was confirmed (${changed.join(", ")}); run namzu schedule confirm ${job.name}`
+    );
+  }
+  let projectCtx;
+  let layers;
+  try {
+    projectCtx = job.workspace === "none" ? ctx : resolveTrustedProjectContext(ctx, folder.canonical);
+    layers = readPermissionLayers({
+      cwd: folder.canonical,
+      env: { ...deps.env ?? process.env, NAMZU_HOME: paths.home },
+      ...job.workspace === "none" ? { includeProject: false } : {}
+    });
+  } catch (error) {
+    return blocked(
+      `config cannot be read: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const policy = compileJobPolicy(job.permissions, {
+    layers,
+    namzuHome: paths.home,
+    folder: job.folder
+  });
+  if (policy.diagnostics.length > 0) {
+    return blocked(`permission rules do not compile: ${policy.diagnostics.join("; ")}`);
+  }
+  if (runKind !== "agent" && process.platform === "win32") {
+    return blocked(
+      `a ${runKind} job cannot run on native Windows: its script would run through cmd.exe, read only as a loose approximation the floor cannot fully verify. Use WSL, where a job\u2019s script runs on the Linux side, or an agent job.`
+    );
+  }
+  const selectedScriptShell = runKind !== "agent" && job.script ? installedCommandShellForDialect(job.script.shell) : void 0;
+  if (runKind !== "agent" && job.script && !selectedScriptShell)
+    return blocked(scriptShellUnavailableReason(job.script.shell));
+  if (runKind !== "agent" && job.script && selectedScriptShell) {
+    const scriptPolicy = compileScriptCheckPolicy(job.permissions, {
+      layers,
+      namzuHome: paths.home,
+      folder: job.folder
+    });
+    const checked = verifyScheduledScript(
+      job.script.body,
+      selectedScriptShell.dialect,
+      scriptPolicy
+    );
+    if (!checked.ok) {
+      return blocked(
+        `the ${runKind === "script" ? "script" : "wake-gate script"} is no longer allowed: ${checked.reason}; run namzu schedule confirm ${job.name} once it is fixed`
+      );
+    }
+  }
+  if (runKind === "script") {
+    return runScriptJob(
+      job,
+      folder.canonical,
+      paths,
+      deps,
+      selectedScriptShell,
+      finish,
+      blocked
+    );
+  }
+  if (!model) return blocked("an agent job has no model; edit the job and confirm it again");
+  let wakeGateContext;
+  if (runKind === "script+agent") {
+    const script = job.script;
+    if (!script) return blocked(`${job.name} is a script+agent job with no wake-gate recorded`);
+    const gateEnv = { ...deps.env ?? process.env, NAMZU_HOME: paths.home };
+    const gate = await runScript(script.body, script.shell, {
+      cwd: folder.canonical,
+      env: gateEnv,
+      timeoutMs: script.timeoutMs,
+      resolvedShell: selectedScriptShell
+    });
+    if (gate.shellUnavailable) return blocked(scriptShellUnavailableReason(gate.shellUnavailable));
+    if (gate.dialectMismatch) {
+      return blocked(
+        `the wake-gate script was confirmed for ${gate.dialectMismatch.expected}, but this host now runs commands as ${gate.dialectMismatch.actual}; run namzu schedule confirm ${job.name} to verify it in the shell that will actually run it`
+      );
+    }
+    scriptOutput = {
+      stdout: capOutput(gate.stdout),
+      stderr: capOutput(gate.stderr)
+    };
+    if (gate.timedOut) {
+      return finish("check-failed", 1, {
+        reason: `the wake-gate script exceeded its ${script.timeoutMs} ms timeout`
+      });
+    }
+    if (gate.exitCode !== 0) {
+      return finish("check-failed", 1, {
+        reason: `the wake-gate script exited ${gate.exitCode ?? "without a code"}`
+      });
+    }
+    const parsed = parseWakeGateOutput(
+      gate.stdout,
+      job.wakeGate?.maxContextChars ?? DEFAULT_WAKE_GATE_CONTEXT_CHARS
+    );
+    if (!parsed.ok) return finish("check-failed", 1, { reason: parsed.reason });
+    gateResult = {
+      wake: parsed.result.wake,
+      contextChars: parsed.result.context.length
+    };
+    if (!parsed.result.wake) return finish("completed", 0, {});
+    const findings = scanSchedulePrompt(parsed.result.context);
+    if (findings.length > 0) warnings.push(...findings.map((f) => `wake-gate context: ${f}`));
+    wakeGateContext = revealHiddenCharacters(parsed.result.context);
+  }
+  const grant = job.permissions.browser;
+  let browser;
+  if (grant) {
+    const checked = await (deps.browserPreflight ?? browserPreflight)(grant, paths.home, {
+      env: deps.env ?? process.env
+    });
+    if (!checked.ok) return blocked(checked.reason);
+    browser = checked;
+    warnings.push(...checked.warnings);
+  }
+  const daemonEnv = readDaemonEnv(paths.daemonEnv);
+  warnings.push(...daemonEnv.warnings);
+  const discoveryEnv = { ...deps.env ?? process.env, ...daemonEnv.values };
+  const agent = deps.agent ?? await import("./agent-UEK2U3RE.js");
+  const probe = await agent.probeAgentSession({ env: discoveryEnv });
+  const detected = probe.detected.find((d) => d.entry.id === model.provider);
+  if (!detected) {
+    return blocked(
+      `no credential for ${model.provider} in the scheduler\u2019s environment; run namzu login, or put the key in ${paths.daemonEnv}`
+    );
+  }
+  const source = credentialSource(detected.source);
+  found.credential = source.text;
+  if (source.borrowed) warnings.push(BORROWED_CREDENTIAL_WARNING);
+  const prefs = {
+    version: 3,
+    providers: [
+      {
+        id: model.provider,
+        ...model.model ? { model: model.model } : {}
+      }
+    ],
+    subagents: { active: [] }
+  };
+  const withheld = withheldTools(job.permissions, policy);
+  calls = new CallTally(withheld);
+  let sessions;
+  try {
+    sessions = await openSessions(folder.canonical, { stateRoot: paths.home });
+    projectSlug = sessions.slug;
+    sessionId = await startConversation(sessions, {
+      origin: { protocol: "cli", kind: "prompt" }
+    });
+    const when = args.scheduledFor ?? startedAt;
+    const tz = job.schedule.kind === "cron" ? job.schedule.tz : void 0;
+    await setTitle(
+      sessions,
+      asSessionId(sessionId),
+      `Scheduled: ${job.name} \xB7 ${describeWhen(when, tz)}`
+    );
+  } catch (error) {
+    return finish("failed", 1, {
+      reason: `the conversation could not be started: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+  writeRunResult(paths, { ...base(), status: "running", exitCode: 0 });
+  const config = projectCtx.config;
+  const session = await agent.createAgentSession(prefs, [detected], {
+    cwd: folder.canonical,
+    stateRoot: paths.home,
+    conversationSessions: sessions,
+    scope: {
+      sessionId: asSessionId(sessionId),
+      topicId: sessions.topicId,
+      projectId: sessions.projectId,
+      tenantId: sessions.tenantId
+    },
+    rules: policy.rules,
+    permissionMode: policy.mode,
+    withheldTools: withheld,
+    ...config.mcpServers ? { mcpServers: config.mcpServers } : {},
+    ...config.plugins ? { plugins: config.plugins } : {},
+    ...config.skills ? { skills: config.skills } : {},
+    ...config.hooks ? { hooks: config.hooks } : {},
+    ...policy.network && config.web ? { web: config.web } : {},
+    ...config.compaction ? { compaction: config.compaction } : {},
+    ...config.memory ? { memory: config.memory } : {},
+    sandbox: job.permissions.execution === "sandbox" ? { ...config.sandbox ?? {}, enabled: true } : { enabled: false },
+    ...job.permissions.additionalDirectories ? { additionalDirectories: [...job.permissions.additionalDirectories] } : {},
+    ...grant && browser ? {
+      browser: {
+        profile: grant.profile,
+        engine: browser.engine,
+        headless: grant.headed ? "never" : "always",
+        // The host checks every landing against the same sites the
+        // gate was given: the grant, what a config file denies, and
+        // nothing else.
+        sites: {
+          ...grant.sites,
+          ...Object.fromEntries(
+            layers.flatMap((layer) => layer.browserDenies ?? []).map((site) => [site, "deny"])
+          ),
+          "*": "deny"
+        },
+        home: paths.home,
+        mode: "unattended"
+      }
+    } : {},
+    limits: {
+      maxIterations: job.budget.maxIterations,
+      tokenBudget: job.budget.tokenBudget,
+      timeoutMs: job.budget.timeoutMs
+    }
+  });
+  const closeAll = /* @__PURE__ */ __name(async () => {
+    await session.close().catch(() => void 0);
+    closeSessions(sessions);
+  }, "closeAll");
+  if (!session.hasProvider) {
+    await closeAll();
+    return blocked(session.errorHint ?? "the provider could not be started");
+  }
+  if (session.mcpFailed.length > 0) {
+    await closeAll();
+    return blocked(
+      `tool servers unavailable: ${session.mcpFailed.map((f) => `${f.name} (${f.reason})`).join(", ")}`
+    );
+  }
+  const abort = new AbortController();
+  const exit = deps.exit ?? ((code) => process.exit(code));
+  const watchdog = setTimeout(
+    () => {
+      abort.abort(new TurnCancelled("user"));
+      void (async () => {
+        finish("timed-out", 1, {
+          reason: `the run exceeded its ${job.budget.timeoutMs} ms wall clock`
+        });
+        settledByWatchdog = true;
+        await releaseHeldSessionLeases().catch(() => void 0);
+        exit(1);
+      })();
+    },
+    job.budget.timeoutMs + (deps.graceMs ?? WATCHDOG_GRACE_MS)
+  );
+  watchdog.unref();
+  let text = "";
+  let totalTokens;
+  let costUsd;
+  let paused = null;
+  let failed = null;
+  let stopReason;
+  const consume = /* @__PURE__ */ __name(async (stream) => {
+    paused = null;
+    failed = null;
+    for await (const event of stream) {
+      switch (event.kind) {
+        case "delta":
+          text += event.text;
+          break;
+        case "usage":
+          totalTokens = event.totalTokens;
+          costUsd = event.cost?.totalCost;
+          break;
+        case "paused":
+          paused = event;
+          turnId = event.turnId;
+          failed = describeTurnInterruption(event);
+          break;
+        case "error":
+          failed = describeTurnInterruption(event);
+          break;
+        case "done":
+          if (event.text !== void 0) text = event.text;
+          stopReason = event.stopReason;
+          if (event.turnId) turnId = event.turnId;
+          break;
+        case "tool-start":
+          log.info("scheduled run tool call", {
+            "namzu.schedule.run_id": args.runId,
+            "namzu.tool.name": event.toolName
+          });
+          break;
+        case "tool-end":
+          calls.observe(event);
+          break;
+      }
+    }
+  }, "consume");
+  try {
+    await consume(
+      session.send([{ role: "user", content: job.prompt, timestamp: Date.now() }], {
+        signal: abort.signal,
+        permissionMode: policy.mode,
+        reviewHold: { reason: HOLD_REASON },
+        systemNote: unattendedNote(job.name, {
+          browser: grant !== void 0,
+          now: now(),
+          tz: job.schedule.kind === "cron" ? job.schedule.tz : hostTimeZone(),
+          ...wakeGateContext !== void 0 ? { wakeGateContext } : {}
+        }),
+        ...model.effort ? { effort: model.effort } : {}
+      })
+    );
+    let waits = 0;
+    let waitedMs = 0;
+    for (; ; ) {
+      const current = paused;
+      if (!current || !(current.providerError || current.failure)) break;
+      const asked = retryAfterMs(current);
+      const decision = pauseWait({
+        waited: waits,
+        ...asked !== void 0 ? { retryAfterMs: asked } : {},
+        waitedMs,
+        budgetMs: job.budget.waitForProviderMs
+      });
+      if (decision.kind === "stop") {
+        await closeAll();
+        clearTimeout(watchdog);
+        return finish("failed", 75, {
+          reason: `${failed ?? "the provider paused the turn"}; not resumed: ${decision.reason}`,
+          ...asked !== void 0 ? { retryAfterMs: asked } : {}
+        });
+      }
+      waits++;
+      await new Promise((resolve) => setTimeout(resolve, decision.delayMs));
+      waitedMs += decision.delayMs;
+      await consume(
+        session.resumePaused({
+          turnId: current.turnId,
+          checkpointId: current.checkpointId,
+          signal: abort.signal,
+          permissionMode: policy.mode,
+          reviewHold: { reason: HOLD_REASON }
+        })
+      );
+    }
+  } finally {
+    clearTimeout(watchdog);
+  }
+  await closeAll();
+  const usage = {
+    ...totalTokens !== void 0 ? { totalTokens } : {},
+    ...costUsd !== void 0 ? { costUsd } : {}
+  };
+  const withUsage = Object.keys(usage).length > 0 ? { usage } : {};
+  const summary = summaryOf(text);
+  const parked = paused;
+  if (parked) {
+    const handoff = parked.handoff ? sanitizeLine(handoffReason(parked.handoff), 300) : "";
+    return finish("awaiting-approval", 0, {
+      reason: handoff || parked.reason,
+      ...handoff ? { handoff: { reason: handoff } } : {},
+      ...summary ? { summary } : {},
+      ...withUsage
+    });
+  }
+  if (failed)
+    return finish("failed", 1, {
+      reason: failed,
+      ...summary ? { summary } : {},
+      ...withUsage
+    });
+  if (stopReason === "timeout") {
+    return finish("timed-out", 1, {
+      reason: `the turn reached its ${job.budget.timeoutMs} ms time limit`,
+      ...summary ? { summary } : {},
+      ...withUsage
+    });
+  }
+  if (stopReason && stopReason !== "end_turn") {
+    return finish("failed", 1, {
+      reason: `the turn did not finish normally: ${stopReason}`,
+      ...summary ? { summary } : {},
+      ...withUsage
+    });
+  }
+  return finish("completed", 0, {
+    ...summary ? { summary } : {},
+    ...withUsage
+  });
+}
+__name(runFire, "runFire");
+async function runScriptJob(job, cwd, paths, deps, selectedShell, finish, blocked) {
+  const script = job.script;
+  if (!script) return blocked(`${job.name} is a script job with no script recorded`);
+  const env = { ...deps.env ?? process.env, NAMZU_HOME: paths.home };
+  let scriptStateRevision;
+  if (script.report === "json-v1") {
+    try {
+      const snapshot = readScriptState(paths, job.id);
+      env.NAMZU_SCHEDULE_STATE = snapshot.state;
+      env.NAMZU_SCHEDULE_STATE_REVISION = String(snapshot.revision);
+      scriptStateRevision = snapshot.revision;
+    } catch (error) {
+      return blocked(
+        `script state cannot be read: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  const result = await runScript(script.body, script.shell, {
+    cwd,
+    env,
+    timeoutMs: script.timeoutMs,
+    resolvedShell: selectedShell
+  });
+  if (result.shellUnavailable) return blocked(scriptShellUnavailableReason(result.shellUnavailable));
+  if (result.dialectMismatch) {
+    return blocked(
+      `the script was confirmed for ${result.dialectMismatch.expected}, but this host now runs commands as ${result.dialectMismatch.actual}; run namzu schedule confirm ${job.name} to verify it in the shell that will actually run it`
+    );
+  }
+  const scriptOutput = {
+    stdout: capOutput(result.stdout),
+    stderr: capOutput(result.stderr)
+  };
+  if (result.timedOut) {
+    return finish("timed-out", 1, {
+      reason: `the script exceeded its ${script.timeoutMs} ms timeout`,
+      scriptOutput
+    });
+  }
+  if (result.exitCode === 0) {
+    if (script.report === "json-v1") {
+      const parsed = parseScriptReport(result.stdout);
+      if (!parsed.ok) return finish("check-failed", 1, { reason: parsed.reason, scriptOutput });
+      return finish("completed", 0, {
+        scriptOutput,
+        scriptReport: parsed.result,
+        scriptStateRevision,
+        ...parsed.result.state === "changed" ? { summary: parsed.result.summary } : {}
+      });
+    }
+    return finish("completed", 0, { scriptOutput });
+  }
+  return finish("failed", result.exitCode ?? 1, {
+    reason: `the script exited ${result.exitCode ?? "without a code"}`,
+    scriptOutput
+  });
+}
+__name(runScriptJob, "runScriptJob");
+function handoffReason(handoff) {
+  const login = handoff.detail?.tool === "browser" ? handoff.detail.loginCommand : void 0;
+  return login ? `${handoff.reason}; sign in again with ${login}` : handoff.reason;
+}
+__name(handoffReason, "handoffReason");
+function describeWhen(iso, tz) {
+  try {
+    return new Intl.DateTimeFormat("en-GB", {
+      dateStyle: "medium",
+      timeStyle: "short",
+      ...tz ? { timeZone: tz } : {}
+    }).format(new Date(iso));
+  } catch {
+    return iso;
+  }
+}
+__name(describeWhen, "describeWhen");
+
+export {
+  takeSuppressedCount,
+  DELIVERY_READ_LIMIT,
+  readSourceDeliveryPage,
+  writeRunResult,
+  readRunResult,
+  isFinal,
+  claimOccurrence,
+  EXIT_STOP_REQUESTED,
+  daemonLogPath,
+  daemonLogSink,
+  sessionLeaseLive,
+  sessionFacts,
+  abandonParkedTurn,
+  noSessionStartGraceMs,
+  ScheduleDaemon,
+  MANUAL_KEY_PREFIX,
+  appendRunRecord,
+  stopRequestPath,
+  requestStop,
+  spawnFireProcess,
+  installedFingerprint,
+  parseFireArgs,
+  runFire
+};
+//# sourceMappingURL=chunk-THZXXVHM.js.map