ever-works-node 0.2.3 → 0.2.5

package/cli.js

@@ -3767,10 +3767,14 @@ var USER_SELECTABLE_WORK_KINDS = [
   "repo",
   "app"
 ];
-var WORK_KINDS = [...USER_SELECTABLE_WORK_KINDS, "company", "campaign", "default"];
+var WORK_KINDS = [...USER_SELECTABLE_WORK_KINDS, "company", "campaign", "project", "default"];
 var WORK_KIND_SET = new Set(WORK_KINDS);
 var GOAL_KINDS = ["metric", "delivery"];
 var GOAL_KIND_SET = new Set(GOAL_KINDS);
+var RECORD_VISIBILITIES = ["private", "team", "organization"];
+var RECORD_VISIBILITY_SET = new Set(RECORD_VISIBILITIES);
+var RECORD_LIST_VIEWS = ["mine", "shared", "organization"];
+var RECORD_LIST_VIEW_SET = new Set(RECORD_LIST_VIEWS);
 var APP_DEPENDENCY_BACKUP_OVERDUE_MS = 26 * 36e5;
 var APP_DEPENDENCY_MANAGED = {
   pgRoleConnectionLimit: 20,
@@ -5002,6 +5006,41 @@ function resolveExclusiveAgentCredentials(grantedNames, env) {
   return { names: grantedNames.filter((name) => !dropped.has(name)), notes };
 }
 __name(resolveExclusiveAgentCredentials, "resolveExclusiveAgentCredentials");
+var CONVENTIONAL_SUBJECT = /^([a-z]+)(\([^)\n]{1,40}\))?(!)?:\s+(\S.*)$/;
+function classifyFleetChangedPaths(paths) {
+  const list = (paths ?? []).map((path2) => path2.replace(/\\/g, "/").trim()).filter(Boolean);
+  if (list.length === 0) return "none";
+  if (list.every(isDocsPath)) return "docs";
+  if (list.every(isTestPath)) return "test";
+  return "mixed";
+}
+__name(classifyFleetChangedPaths, "classifyFleetChangedPaths");
+function retypeFleetCommitMessage(message, changedPaths) {
+  if (typeof message !== "string" || !message) return message;
+  const newline = message.indexOf("\n");
+  const firstLine = newline === -1 ? message : message.slice(0, newline);
+  const rest = newline === -1 ? "" : message.slice(newline);
+  const parsed = CONVENTIONAL_SUBJECT.exec(firstLine);
+  if (!parsed) return message;
+  const change = classifyFleetChangedPaths(changedPaths);
+  const type = change === "docs" ? "docs" : change === "test" ? "test" : null;
+  if (!type || parsed[1] === type) return message;
+  return `${type}${firstLine.slice(parsed[1].length)}${rest}`;
+}
+__name(retypeFleetCommitMessage, "retypeFleetCommitMessage");
+var DOC_EXTENSIONS = /\.(?:md|mdx|markdown|rst|adoc|txt)$/i;
+var DOC_DIRECTORY = /(?:^|\/)(?:docs?|documentation)\//i;
+var DOC_FILENAMES = /(?:^|\/)(?:readme|changelog|contributing|license|licence|notice|authors|code_of_conduct)(?:\.[a-z]+)?$/i;
+function isDocsPath(path2) {
+  return DOC_EXTENSIONS.test(path2) || DOC_DIRECTORY.test(path2) || DOC_FILENAMES.test(path2);
+}
+__name(isDocsPath, "isDocsPath");
+var TEST_FILE = /(?:^|[./_-])(?:spec|test|tests|e2e)\.[cm]?[jt]sx?$|_test\.(?:go|py|rb)$|(?:^|\/)test_[^/]+\.py$/i;
+var TEST_DIRECTORY = /(?:^|\/)(?:__tests__|__snapshots__|__mocks__|__fixtures__|tests?|e2e|spec|fixtures)\//i;
+function isTestPath(path2) {
+  return TEST_FILE.test(path2) || TEST_DIRECTORY.test(path2) || /\.snap$/i.test(path2);
+}
+__name(isTestPath, "isTestPath");
 var INBOX_MAX_TITLE_CHARS = 300;
 var FLEET_TASK_WORKSPACE_MAX_MOUNTS = 8;
 var FLEET_TASK_WORKSPACE_MOUNT_DIR_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,62}[A-Za-z0-9_-])?$/;
@@ -5515,6 +5554,275 @@ function truncateToUtf8Bytes(value, maxBytes) {
   return { value: decoded.replace(/\uFFFD+$/, "").trimEnd(), truncated: true };
 }
 __name(truncateToUtf8Bytes, "truncateToUtf8Bytes");
+var FLEET_JOB_FAILURE_KIND_MODEL_USAGE_LIMIT = "model_usage_limit";
+var FLEET_MODEL_USAGE_LIMIT_FALLBACK_MS = 60 * 60 * 1e3;
+var FLEET_MODEL_USAGE_LIMIT_MIN_MS = 60 * 1e3;
+var FLEET_MODEL_USAGE_LIMIT_MAX_MS = 8 * 24 * 60 * 60 * 1e3;
+var FLEET_MODEL_USAGE_LIMIT_RESET_SLACK_MS = 60 * 1e3;
+var FLEET_MODEL_USAGE_LIMIT_MAX_MESSAGE_LENGTH = 300;
+var LIMIT_SIGNATURES = [
+  { pattern: /\bhit (?:your|the) (?:[\w-]+ )?(?:usage |rate )?limit\b/i, strict: true },
+  {
+    pattern: /\b(?:usage|weekly|daily|session|5[- ]hour|five[- ]hour) limit (?:has been )?(?:reached|exceeded|hit)\b/i,
+    strict: true
+  },
+  { pattern: /\busage[_ ]limit[_ ](?:reached|exceeded)\b/i, strict: true },
+  { pattern: /\brate_limit_error\b/, strict: true },
+  { pattern: /\bexceeded retry limit,? last status:? 429\b/i, strict: true },
+  { pattern: /\b429\b[^\n]{0,40}\btoo many requests\b/i, strict: true },
+  { pattern: /\bAPI Error:? 429\b/i, strict: true },
+  { pattern: /\brate[- ]limit(?:ed)?\b[^\n]{0,20}\b(?:reached|exceeded)\b/i, strict: false },
+  { pattern: /\bout of (?:extra )?usage\b/i, strict: false }
+];
+function detectFleetModelUsageLimit(text, options = {}) {
+  if (typeof text !== "string" || !text.trim()) return null;
+  const strict = options.strict === true;
+  const match = LIMIT_SIGNATURES.find((signature) => (!strict || signature.strict) && signature.pattern.test(text));
+  if (!match) return null;
+  const nowMs = toEpochMs(options.now);
+  const provider = typeof options.provider === "string" && options.provider.trim() ? options.provider.trim() : "claude-code";
+  const resetsAtMs = parseResetInstant(text, nowMs, options.timeZone);
+  const resetsAt = resetsAtMs !== null && resetsAtMs > nowMs ? resetsAtMs : null;
+  return {
+    provider,
+    window: classifyWindow(text),
+    resetsAt: resetsAt === null ? null : new Date(resetsAt).toISOString(),
+    retryAfter: new Date(
+      clampRetryAfterMs(
+        resetsAt === null ? nowMs + FLEET_MODEL_USAGE_LIMIT_FALLBACK_MS : resetsAt + FLEET_MODEL_USAGE_LIMIT_RESET_SLACK_MS,
+        nowMs
+      )
+    ).toISOString(),
+    message: describeLimitSentence(text, match.pattern)
+  };
+}
+__name(detectFleetModelUsageLimit, "detectFleetModelUsageLimit");
+function clampRetryAfterMs(retryAfterMs, nowMs) {
+  const floor = nowMs + FLEET_MODEL_USAGE_LIMIT_MIN_MS;
+  const ceiling = nowMs + FLEET_MODEL_USAGE_LIMIT_MAX_MS;
+  if (!Number.isFinite(retryAfterMs)) return nowMs + FLEET_MODEL_USAGE_LIMIT_FALLBACK_MS;
+  return Math.min(Math.max(retryAfterMs, floor), ceiling);
+}
+__name(clampRetryAfterMs, "clampRetryAfterMs");
+function describeFleetModelProvider(provider) {
+  switch (provider) {
+    case "claude-code":
+      return "Claude Code";
+    case "codex":
+      return "Codex";
+    default:
+      return provider;
+  }
+}
+__name(describeFleetModelProvider, "describeFleetModelProvider");
+function describeFleetModelUsageLimitWindow(window) {
+  switch (window) {
+    case "weekly":
+      return "weekly limit";
+    case "session":
+      return "5-hour limit";
+    case "daily":
+      return "daily limit";
+    case "rate":
+      return "rate limit";
+    default:
+      return "usage limit";
+  }
+}
+__name(describeFleetModelUsageLimitWindow, "describeFleetModelUsageLimitWindow");
+function toEpochMs(value) {
+  if (value instanceof Date) return value.getTime();
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  return Date.now();
+}
+__name(toEpochMs, "toEpochMs");
+function classifyWindow(text) {
+  if (/\bweekly\b|\bper week\b/i.test(text)) return "weekly";
+  if (/\b(?:5|five)[- ]hour\b|\bsession limit\b/i.test(text)) return "session";
+  if (/\bdaily\b|\bper day\b/i.test(text)) return "daily";
+  if (/\b429\b|rate_limit_error|\brate[- ]limit/i.test(text)) return "rate";
+  return "usage";
+}
+__name(classifyWindow, "classifyWindow");
+function trimSentence(text) {
+  const clean = text.replace(/[\u0000-\u001f\u007f]+/g, " ").replace(/\s+/g, " ").trim();
+  const points = Array.from(clean);
+  return points.length > FLEET_MODEL_USAGE_LIMIT_MAX_MESSAGE_LENGTH ? `${points.slice(0, FLEET_MODEL_USAGE_LIMIT_MAX_MESSAGE_LENGTH - 1).join("").trimEnd()}\u2026` : clean;
+}
+__name(trimSentence, "trimSentence");
+function describeLimitSentence(text, pattern) {
+  const line = text.split(/\r?\n/).find((candidate) => pattern.test(candidate));
+  return trimSentence(line ?? text);
+}
+__name(describeLimitSentence, "describeLimitSentence");
+var MONTHS = {
+  jan: 0,
+  feb: 1,
+  mar: 2,
+  apr: 3,
+  may: 4,
+  jun: 5,
+  jul: 6,
+  aug: 7,
+  sep: 8,
+  sept: 8,
+  oct: 9,
+  nov: 10,
+  dec: 11
+};
+function parseResetInstant(text, nowMs, timeZone) {
+  const epoch = /usage limit reached\|(\d{10,13})\b/i.exec(text);
+  if (epoch) {
+    const value = Number(epoch[1]);
+    return epoch[1].length >= 13 ? value : value * 1e3;
+  }
+  const iso = /\b(?:resets?|reset at|try again at|available again at|until)\s+(?:at\s+)?(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2}))/i.exec(
+    text
+  );
+  if (iso) {
+    const value = Date.parse(iso[1]);
+    if (Number.isFinite(value)) return value;
+  }
+  const relative6 = /\b(?:resets?|reset|try again|available again|retry)\s+in\s+((?:\d+\s*(?:d|days?|h|hrs?|hours?|m|mins?|minutes?|s|secs?|seconds?)\b(?:[\s,]+(?:and )?)?)+)/i.exec(
+    text
+  );
+  if (relative6) {
+    const ms = parseDuration(relative6[1]);
+    if (ms > 0) return nowMs + ms;
+  }
+  const wall = /\b(?:resets?|reset at|will reset at|try again at|available again at)\s+(?:at\s+|on\s+)?(?:(jan|feb|mar|apr|may|jun|jul|aug|sept?|oct|nov|dec)[a-z]*\.?\s+(\d{1,2})(?:st|nd|rd|th)?,?\s+(?:at\s+)?)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\b(?:\s*\(([A-Za-z_]+(?:\/[A-Za-z0-9_+-]+){0,2}|UTC|GMT)\))?/i.exec(
+    text
+  );
+  if (wall) {
+    const [, monthName, dayText, hourText, minuteText, meridiem, zoneText] = wall;
+    let hour = Number(hourText);
+    const minute = minuteText ? Number(minuteText) : 0;
+    if (!meridiem && !minuteText && !monthName) {
+      return null;
+    }
+    if (meridiem) {
+      if (hour < 1 || hour > 12) return null;
+      hour = hour % 12 + (meridiem.toLowerCase() === "pm" ? 12 : 0);
+    }
+    if (hour > 23 || minute > 59) return null;
+    const zone = resolveZone(zoneText) ?? resolveZone(timeZone) ?? "UTC";
+    const today = zonedParts(nowMs, zone);
+    if (monthName) {
+      const month = MONTHS[monthName.toLowerCase()];
+      const day = Number(dayText);
+      if (month === void 0 || day < 1 || day > 31) return null;
+      let candidate2 = zonedWallTimeToUtc(today.year, month, day, hour, minute, zone);
+      if (candidate2 < nowMs - 24 * 60 * 60 * 1e3) {
+        candidate2 = zonedWallTimeToUtc(today.year + 1, month, day, hour, minute, zone);
+      }
+      return candidate2;
+    }
+    let candidate = zonedWallTimeToUtc(today.year, today.month, today.day, hour, minute, zone);
+    if (candidate <= nowMs) {
+      candidate = zonedWallTimeToUtc(today.year, today.month, today.day + 1, hour, minute, zone);
+    }
+    return candidate;
+  }
+  return null;
+}
+__name(parseResetInstant, "parseResetInstant");
+function parseDuration(text) {
+  let total = 0;
+  let index = 0;
+  const length = Math.min(text.length, 200);
+  while (index < length) {
+    if (!isDigit(text.charCodeAt(index))) {
+      index += 1;
+      continue;
+    }
+    let value = 0;
+    while (index < length && isDigit(text.charCodeAt(index))) {
+      value = Math.min(value * 10 + (text.charCodeAt(index) - 48), 1e6);
+      index += 1;
+    }
+    while (index < length && text[index] === " ") index += 1;
+    let word = "";
+    while (index < length && /[a-z]/i.test(text[index])) {
+      word += text[index].toLowerCase();
+      index += 1;
+    }
+    const unitMs = DURATION_UNITS[word];
+    if (unitMs !== void 0) total += value * unitMs;
+  }
+  return total;
+}
+__name(parseDuration, "parseDuration");
+var DURATION_UNITS = {
+  d: 864e5,
+  day: 864e5,
+  days: 864e5,
+  h: 36e5,
+  hr: 36e5,
+  hrs: 36e5,
+  hour: 36e5,
+  hours: 36e5,
+  m: 6e4,
+  min: 6e4,
+  mins: 6e4,
+  minute: 6e4,
+  minutes: 6e4,
+  s: 1e3,
+  sec: 1e3,
+  secs: 1e3,
+  second: 1e3,
+  seconds: 1e3
+};
+function isDigit(code) {
+  return code >= 48 && code <= 57;
+}
+__name(isDigit, "isDigit");
+function resolveZone(zone) {
+  if (typeof zone !== "string" || !zone.trim()) return null;
+  const candidate = zone.trim();
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: candidate });
+    return candidate;
+  } catch {
+    return null;
+  }
+}
+__name(resolveZone, "resolveZone");
+function zonedParts(instantMs, zone) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: zone,
+    hourCycle: "h23",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  }).formatToParts(new Date(instantMs));
+  const get = /* @__PURE__ */ __name((type) => Number(parts.find((part) => part.type === type)?.value ?? 0), "get");
+  return {
+    year: get("year"),
+    month: get("month") - 1,
+    day: get("day"),
+    hour: get("hour") % 24,
+    minute: get("minute"),
+    second: get("second")
+  };
+}
+__name(zonedParts, "zonedParts");
+function zoneOffsetMs(instantMs, zone) {
+  const whole = Math.floor(instantMs / 1e3) * 1e3;
+  const p = zonedParts(whole, zone);
+  return Date.UTC(p.year, p.month, p.day, p.hour, p.minute, p.second) - whole;
+}
+__name(zoneOffsetMs, "zoneOffsetMs");
+function zonedWallTimeToUtc(year, month, day, hour, minute, zone) {
+  const asIfUtc = Date.UTC(year, month, day, hour, minute, 0);
+  const firstOffset = zoneOffsetMs(asIfUtc, zone);
+  const guess = asIfUtc - firstOffset;
+  const secondOffset = zoneOffsetMs(guess, zone);
+  return secondOffset === firstOffset ? guess : asIfUtc - secondOffset;
+}
+__name(zonedWallTimeToUtc, "zonedWallTimeToUtc");
 var FLEET_ENROLLABLE_NODE_KINDS = ["desktop-node", "node"];
 function isFleetEnrollableNodeKind(value) {
   return typeof value === "string" && FLEET_ENROLLABLE_NODE_KINDS.includes(value);
@@ -6120,6 +6428,8 @@ var EVER_STATS_KEY_ID_HEADER = CONSTANTS.stats_headers.key_id;
 var EVER_STATS_SIGNATURE_PREFIX = CONSTANTS.stats_signature_prefix;
 var EVER_STATS_MAX_BODY_BYTES = CONSTANTS.stats.max_bytes;
 var DOMAIN_EVENT_CATALOG = [
+  // EW-P2-6 — `org:write` (and the app) create Organizations.
+  { type: "organization.created", domain: "organization", aggregateType: "organization", phase: "P2" },
   { type: "organization.updated", domain: "organization", aggregateType: "organization", phase: "P1" },
   {
     type: "organization.member.added",
@@ -6166,10 +6476,10 @@ var DOMAIN_EVENT_CATALOG = [
   { type: "mission.updated", domain: "missions", aggregateType: "mission", phase: "P2" },
   { type: "mission.status_changed", domain: "missions", aggregateType: "mission", phase: "P2" },
   { type: "mission.deleted", domain: "missions", aggregateType: "mission", phase: "P2" },
-  { type: "mission.goal.linked", domain: "missions", aggregateType: "mission", phase: "P2" },
-  { type: "mission.goal.unlinked", domain: "missions", aggregateType: "mission", phase: "P2" },
-  { type: "mission.work.linked", domain: "missions", aggregateType: "mission", phase: "P2" },
-  { type: "mission.work.unlinked", domain: "missions", aggregateType: "mission", phase: "P2" },
+  { type: "mission.goal.linked", domain: "missions", aggregateType: "mission", phase: "P2", child: "goal" },
+  { type: "mission.goal.unlinked", domain: "missions", aggregateType: "mission", phase: "P2", child: "goal" },
+  { type: "mission.work.linked", domain: "missions", aggregateType: "mission", phase: "P2", child: "work" },
+  { type: "mission.work.unlinked", domain: "missions", aggregateType: "mission", phase: "P2", child: "work" },
   { type: "goal.created", domain: "goals", aggregateType: "goal", phase: "P2" },
   { type: "goal.updated", domain: "goals", aggregateType: "goal", phase: "P2" },
   { type: "goal.status_changed", domain: "goals", aggregateType: "goal", phase: "P2" },
@@ -6226,6 +6536,11 @@ var DOMAIN_EVENT_TYPES = DOMAIN_EVENT_CATALOG.map((entry) => entry.type);
 var CATALOG_BY_TYPE = new Map(
   DOMAIN_EVENT_CATALOG.map((entry) => [entry.type, entry])
 );
+var RECIPIENT_SCOPED_EVENT_DOMAINS = {
+  inbox: "inbox:read",
+  email: "email:read"
+};
+var RECIPIENT_EVENT_SCOPES = Object.values(RECIPIENT_SCOPED_EVENT_DOMAINS);
 var INTEGRATION_SCOPES = [
   "org:read",
   "org:write",
@@ -7371,237 +7686,574 @@ function readPendingComputerSessions(payload) {
 }
 __name(readPendingComputerSessions, "readPendingComputerSessions");
 
-// src/core/api-base.ts
-var API_URL_ENV = "EVER_WORKS_NODE_API_URL";
-function rawPin(env) {
-  const value = env[API_URL_ENV];
-  if (typeof value !== "string") {
+// src/core/heartbeat.ts
+var systemScheduler = {
+  setTimeout: /* @__PURE__ */ __name((callback, ms) => setTimeout(callback, ms), "setTimeout"),
+  clearTimeout: /* @__PURE__ */ __name((handle) => clearTimeout(handle), "clearTimeout")
+};
+var OPTIONAL_DESCRIPTION_FIELD_TIERS = [
+  // NEWEST first. Node lifecycle + remote node limits (self-build slices
+  // AR, AS). Tiered (review): `cliVersions` goes out on EVERY beat of a
+  // node with a pinned CLI, so an upgraded node talking to a platform that
+  // predates it would otherwise drop the worker state and housekeeping
+  // along with it — losing health signals that platform DOES understand,
+  // for the life of the process. Stripping the newest tier first keeps them.
+  ["cliVersions", "maxConcurrentJobs", "maxCpuPercent", "maxMemoryMb"],
+  // Fleet health signals (EW-776) and node housekeeping (EW-803).
+  [
+    "workerState",
+    "workerStateReason",
+    "minFreeDiskBytes",
+    "workspaceCount",
+    "workspaceBytes",
+    "lastReclaimAt",
+    "lastReclaimFreedBytes"
+  ]
+];
+function untilHeartbeatAccepted(loop, shouldWait = () => true) {
+  const verdict = /* @__PURE__ */ __name((state) => {
+    if (state.state === "connected") return true;
+    if (state.state === "stopped" || !shouldWait()) return false;
     return null;
-  }
-  const trimmed = value.trim();
-  return trimmed ? trimmed : null;
+  }, "verdict");
+  const now = verdict(loop.getState());
+  if (now !== null) return Promise.resolve(now);
+  return new Promise((resolve9) => {
+    const unsubscribe = loop.onChange((state) => {
+      const settled = verdict(state);
+      if (settled === null) return;
+      unsubscribe();
+      resolve9(settled);
+    });
+  });
 }
-__name(rawPin, "rawPin");
-function readApiUrlPin(env = process.env) {
-  const raw = rawPin(env);
-  return raw === null ? null : normalizeApiUrl(raw);
+__name(untilHeartbeatAccepted, "untilHeartbeatAccepted");
+function computeBackoffDelay(intervalMs, failures, maxMs) {
+  if (failures <= 0) {
+    return intervalMs;
+  }
+  const exponent = Math.min(failures, 30);
+  const delay2 = intervalMs * 2 ** exponent;
+  return Math.min(delay2, maxMs);
 }
-__name(readApiUrlPin, "readApiUrlPin");
-function resolveApiBase(config, env = process.env) {
-  const configuredUrl = config.apiUrl;
-  const pinnedTo = readApiUrlPin(env);
-  if (pinnedTo === null) {
-    return { url: configuredUrl, source: "config", configuredUrl, pinnedTo: null, mismatch: false };
+__name(computeBackoffDelay, "computeBackoffDelay");
+var HeartbeatLoop = class {
+  static {
+    __name(this, "HeartbeatLoop");
   }
-  return {
-    url: pinnedTo,
-    source: "pin",
-    configuredUrl,
-    pinnedTo,
-    mismatch: pinnedTo !== configuredUrl
+  options;
+  scheduler;
+  now;
+  listeners = /* @__PURE__ */ new Set();
+  timer = null;
+  running = false;
+  inFlight = null;
+  /**
+   * How many optional-field TIERS (newest first) this platform has proven
+   * it predates; from then on the beat leaves those tiers out. 0 = it
+   * takes everything. Process-scoped on purpose — a platform upgrade is a
+   * restart-shaped event for the node, and re-probing on every beat would
+   * mean one wasted round trip per beat, forever, against an API that
+   * will never accept them.
+   */
+  strippedTiers = 0;
+  state = {
+    state: "idle",
+    lastHeartbeatAt: null,
+    consecutiveFailures: 0,
+    nextAttemptInMs: null,
+    lastError: null,
+    lastErrorKind: null,
+    node: null
   };
-}
-__name(resolveApiBase, "resolveApiBase");
-function describeApiBase(base) {
-  if (base.source === "config") {
-    return `${base.url} (from the enrolled config)`;
+  constructor(options) {
+    this.options = {
+      ...options,
+      intervalMs: options.intervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS,
+      maxBackoffMs: options.maxBackoffMs ?? MAX_HEARTBEAT_BACKOFF_MS
+    };
+    this.scheduler = options.scheduler ?? systemScheduler;
+    this.now = options.now ?? (() => Date.now());
+    this.options.logger?.protect(options.secret);
   }
-  if (!base.mismatch) {
-    return `${base.url} (pinned via ${API_URL_ENV}; matches the enrolled origin)`;
+  getState() {
+    return { ...this.state };
   }
-  return `${base.url} (PINNED via ${API_URL_ENV}) \u2014 enrolled against ${base.configuredUrl}. The pin does not match the enrolled origin: this node has no credential on the pinned platform, so every call will be refused with 401 until the pin is corrected or the node is re-enrolled.`;
-}
-__name(describeApiBase, "describeApiBase");
-
-// src/core/auth-client.ts
-var EVER_ID_DEVICE_SCOPE = ["openid", "email", EVER_ID_SCOPES.SESSION_EXCHANGE].join(" ");
-
-// src/core/telemetry-probe.ts
-var AGENT_CLI_CANDIDATES = ["claude", "codex", "gemini", "opencode"];
-function parseCliVersion(stdout) {
-  if (typeof stdout !== "string") return null;
-  const match = /\b(\d+\.\d+(?:\.\d+)?(?:[-+][0-9A-Za-z.-]+)?)\b/.exec(stdout);
-  return match ? match[1] : null;
-}
-__name(parseCliVersion, "parseCliVersion");
-async function detectAgentCliVersion(runner, candidates = AGENT_CLI_CANDIDATES) {
-  for (const command of candidates) {
-    try {
-      const result = await runner.run(command, ["--version"]);
-      if (result.code !== 0) continue;
-      const version = parseCliVersion(`${result.stdout ?? ""}
-${result.stderr ?? ""}`);
-      if (!version) continue;
-      return `${command} ${version}`.slice(0, FLEET_MAX_CLI_VERSION_LENGTH);
-    } catch {
-      continue;
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** Start beating. Resolves once the FIRST beat has settled. */
+  start() {
+    if (this.running) {
+      return this.inFlight ?? Promise.resolve();
     }
+    this.running = true;
+    return this.tick();
   }
-  return null;
-}
-__name(detectAgentCliVersion, "detectAgentCliVersion");
-async function detectDiskFreeBytes(io, path2) {
-  try {
-    const free = await io.freeBytes(path2);
-    if (typeof free !== "number" || !Number.isFinite(free) || free < 0) return null;
-    return Math.floor(free);
-  } catch {
-    return null;
+  /** Stop beating and cancel any pending timer. */
+  stop() {
+    this.running = false;
+    this.cancelTimer();
+    this.patch({ state: "stopped", nextAttemptInMs: null });
   }
-}
-__name(detectDiskFreeBytes, "detectDiskFreeBytes");
-var MODEL_IDENTITY_CACHE_TTL_MS = 5 * 6e4;
-function parseClaudeAuthStatus(stdout) {
-  let parsed;
-  try {
-    parsed = JSON.parse(stdout.trim());
-  } catch {
-    return null;
+  /** Await the in-flight beat, if any (test/shutdown helper). */
+  async settled() {
+    await this.inFlight;
   }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
-  const status = parsed;
-  if (status.loggedIn !== true) return "claude-code: not logged in";
-  const email = compactString(status.email);
-  const org = compactString(status.orgName);
-  const plan = compactString(status.subscriptionType);
-  const method = compactString(status.authMethod);
-  const who = email ?? (method ? `${method} login` : "logged in");
-  const details = [org, plan].filter((part) => part !== null);
-  return `claude-code: ${who}${details.length > 0 ? ` (${details.join(", ")})` : ""}`;
-}
-__name(parseClaudeAuthStatus, "parseClaudeAuthStatus");
-function parseCodexLoginStatus(stdout) {
-  const text = stdout.trim().toLowerCase();
-  if (!text) return null;
-  if (text.includes("not logged in")) return "codex: not logged in";
-  if (text.includes("chatgpt")) return "codex: chatgpt";
-  if (text.includes("api key")) return "codex: api-key";
-  if (text.includes("logged in")) return "codex: logged in";
-  return null;
-}
-__name(parseCodexLoginStatus, "parseCodexLoginStatus");
-function compactString(value) {
-  if (typeof value !== "string") return null;
-  const cleaned = value.replace(/[\u0000-\u001F\u007F]+/g, " ").trim();
-  return cleaned ? cleaned : null;
-}
-__name(compactString, "compactString");
-async function detectModelIdentity(runner, paths = {}) {
-  const candidates = [
-    { command: paths["claude-code"] || "claude", args: ["auth", "status", "--json"], parse: parseClaudeAuthStatus },
-    { command: paths.codex || "codex", args: ["login", "status"], parse: parseCodexLoginStatus }
-  ];
-  for (const candidate of candidates) {
-    try {
-      const result = await runner.run(candidate.command, candidate.args);
-      const stdout = result.stdout ?? "";
-      const stderr = result.stderr ?? "";
-      const label = candidate.parse(stdout) ?? candidate.parse(`${stdout}
-${stderr}`);
-      if (label) return label.slice(0, FLEET_MAX_MODEL_IDENTITY_LENGTH);
-    } catch {
-      continue;
+  /** Run one beat now. Exposed so the UI can offer "retry" and tests can step. */
+  tick() {
+    const run = this.runOnce().finally(() => {
+      if (this.inFlight === run) {
+        this.inFlight = null;
+      }
+    });
+    this.inFlight = run;
+    return run;
+  }
+  async runOnce() {
+    if (!this.running) {
+      return;
+    }
+    this.cancelTimer();
+    if (this.state.state !== "connected") {
+      this.patch({ state: "connecting" });
+    }
+    try {
+      const description = await this.options.describe();
+      this.onSuccess(await this.beat(description));
+    } catch (error) {
+      this.onFailure(error);
     }
+    this.scheduleNext();
   }
-  return null;
-}
-__name(detectModelIdentity, "detectModelIdentity");
-function cacheProbe(probe, ttlMs = MODEL_IDENTITY_CACHE_TTL_MS, now = Date.now) {
-  let value = null;
-  let expiresAt = Number.NEGATIVE_INFINITY;
-  let inFlight = null;
-  return async () => {
-    if (now() < expiresAt) return value;
-    if (inFlight) return inFlight;
-    inFlight = probe().then((fresh) => {
-      value = fresh;
-      expiresAt = now() + ttlMs;
-      return fresh;
-    }).finally(() => {
-      inFlight = null;
+  /**
+   * Send one beat, tolerating a platform that predates the optional
+   * self-description fields (the worker state, EW-776; the housekeeping
+   * report, EW-803).
+   *
+   * The API validates heartbeats with `whitelist + forbidNonWhitelisted`,
+   * so a field an older build does not know is not ignored — it 400s the
+   * whole request. A 400 is a FAILED beat, a failed beat backs off, and
+   * enough of them sweep the node to `offline`. Which would mean shipping
+   * a health-reporting feature whose failure mode is "every node in a
+   * mixed-version fleet goes dark": the exact class of outage this slice
+   * was written to end.
+   *
+   * So a 400 on a beat that CARRIED those fields is retried once,
+   * immediately, without them. If that succeeds the platform is simply
+   * older than this daemon; we latch, say so once, and keep reporting
+   * liveness. The retry costs one request, once per process.
+   *
+   * Inferring "the field was rejected" from a bare 400 is deliberate and
+   * has a cost worth stating: `FleetClient` never surfaces server bodies
+   * (fixed client-authored messages only), so a 400 caused by something
+   * else on such a beat also latches, and this node reports liveness only
+   * until it restarts. That is the safe direction — the node stays
+   * observable either way, and only the extra signal is lost.
+   */
+  async beat(description) {
+    const credential = { nodeId: this.options.nodeId, secret: this.options.secret };
+    let sent = stripTiers(description, this.strippedTiers);
+    try {
+      return await this.options.client.heartbeat({ ...credential, ...sent });
+    } catch (error) {
+      if (!isFieldRejection(error)) throw error;
+      let lastError = error;
+      for (let tiers = this.strippedTiers + 1; tiers <= OPTIONAL_DESCRIPTION_FIELD_TIERS.length; tiers += 1) {
+        const candidate = stripTiers(description, tiers);
+        if (Object.keys(candidate).length === Object.keys(sent).length) continue;
+        sent = candidate;
+        try {
+          const result = await this.options.client.heartbeat({ ...credential, ...candidate });
+          this.strippedTiers = tiers;
+          this.options.logger?.warn(
+            tiers >= OPTIONAL_DESCRIPTION_FIELD_TIERS.length ? "Platform rejected the optional self-description fields (worker state, housekeeping); it predates them. Reporting liveness only until this node restarts." : "Platform rejected the newest optional self-description fields (pinned CLI versions, enforced limits); it predates them. Still reporting worker state and housekeeping; the newer fields stay off until this node restarts."
+          );
+          return result;
+        } catch (retryError) {
+          if (!isFieldRejection(retryError)) throw retryError;
+          lastError = retryError;
+        }
+      }
+      throw lastError;
+    }
+  }
+  onSuccess(result) {
+    this.patch({
+      state: "connected",
+      lastHeartbeatAt: this.now(),
+      consecutiveFailures: 0,
+      lastError: null,
+      lastErrorKind: null,
+      node: result.node
     });
-    return inFlight;
-  };
-}
-__name(cacheProbe, "cacheProbe");
-
-// src/core/executors/model-cli.ts
-var MODEL_CLI_EMPTY_MCP_CONFIG = `${JSON.stringify({ mcpServers: {} }, null, 2)}
-`;
-function modelCliMcpIsolationEnv(provider) {
-  return provider === "claude-code" ? { ENABLE_CLAUDEAI_MCP_SERVERS: "false" } : null;
-}
-__name(modelCliMcpIsolationEnv, "modelCliMcpIsolationEnv");
-function claudeManagedMcpConfigPath(platform = process.platform) {
-  if (platform === "win32") return "C:\\Program Files\\ClaudeCode\\managed-mcp.json";
-  if (platform === "darwin") return "/Library/Application Support/ClaudeCode/managed-mcp.json";
-  return "/etc/claude-code/managed-mcp.json";
-}
-__name(claudeManagedMcpConfigPath, "claudeManagedMcpConfigPath");
-function claudeManagedMcpConfigInEffect(raw) {
-  if (typeof raw !== "string" || !raw.trim()) return false;
-  try {
-    const parsed = JSON.parse(raw);
-    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed);
-  } catch {
-    return false;
+    if (this.options.onAccepted) {
+      try {
+        this.options.onAccepted(result);
+      } catch {
+      }
+    }
   }
-}
-__name(claudeManagedMcpConfigInEffect, "claudeManagedMcpConfigInEffect");
-var ModelCliCommandError = class extends Error {
-  static {
-    __name(this, "ModelCliCommandError");
+  onFailure(error) {
+    const kind = error instanceof FleetClientError ? error.kind : "network";
+    const raw = error instanceof Error ? error.message : String(error);
+    const message = this.options.logger?.redact(raw) ?? raw;
+    const failures = this.state.consecutiveFailures + 1;
+    this.patch({
+      // `unauthorized` is sticky and visible: the operator has to act
+      // (re-enable the node in Fleet, or re-enroll). We keep retrying at
+      // the backoff ceiling so a re-enabled node recovers on its own.
+      state: kind === "unauthorized" ? "unauthorized" : "retrying",
+      consecutiveFailures: failures,
+      lastError: message,
+      lastErrorKind: kind
+    });
+    this.options.logger?.warn(`Heartbeat failed (attempt ${failures}): ${message}`);
   }
-  constructor(message) {
-    super(message);
-    this.name = "ModelCliCommandError";
+  scheduleNext() {
+    if (!this.running) {
+      return;
+    }
+    const delay2 = computeBackoffDelay(
+      this.options.intervalMs,
+      this.state.consecutiveFailures,
+      this.options.maxBackoffMs
+    );
+    this.patch({ nextAttemptInMs: delay2 });
+    this.timer = this.scheduler.setTimeout(() => {
+      this.timer = null;
+      void this.tick();
+    }, delay2);
   }
-};
-var MODEL_CLI_STEP_ID = "model";
-var MODEL_CLI_OUTPUT_TAIL_BYTES = 8 * 1024;
-var MODEL_CLI_MAX_OUTPUT_BYTES = 8 * 1024 * 1024;
-var ABSOLUTE_WIN32 = /^[A-Za-z]:[\\/]/;
-var UNSAFE_PATH_CHARS = /[\0\r\n"'`$&|;<>%!^]/;
-function quoteShellPath(path2, platform = process.platform) {
-  if (typeof path2 !== "string" || !path2.trim()) {
-    throw new ModelCliCommandError("Path must not be empty");
+  cancelTimer() {
+    if (this.timer !== null) {
+      this.scheduler.clearTimeout(this.timer);
+      this.timer = null;
+    }
   }
-  if (UNSAFE_PATH_CHARS.test(path2)) {
-    throw new ModelCliCommandError("Path contains characters the shell could interpret");
+  patch(next) {
+    this.state = { ...this.state, ...next };
+    const snapshot = this.getState();
+    for (const listener of this.listeners) {
+      listener(snapshot);
+    }
   }
-  const absolute = platform === "win32" ? ABSOLUTE_WIN32.test(path2) || path2.startsWith("\\\\") : path2.startsWith("/");
-  if (!absolute) {
-    throw new ModelCliCommandError("Path must be absolute");
+};
+function stripTiers(description, tiers) {
+  const out = {};
+  const dropped = new Set(OPTIONAL_DESCRIPTION_FIELD_TIERS.slice(0, tiers).flat());
+  for (const [key, value] of Object.entries(description)) {
+    if (value === void 0 || dropped.has(key)) continue;
+    out[key] = value;
   }
-  return `"${path2}"`;
+  return out;
 }
-__name(quoteShellPath, "quoteShellPath");
-function assertMcpServerName(name) {
-  if (typeof name !== "string" || !MCP_SERVER_NAME_PATTERN.test(name)) {
-    throw new ModelCliCommandError("MCP server name is not an opaque identifier");
-  }
-  return name;
+__name(stripTiers, "stripTiers");
+function isFieldRejection(error) {
+  return error instanceof FleetClientError && error.kind === "invalid-request" && error.status === 400;
 }
-__name(assertMcpServerName, "assertMcpServerName");
-function assertLoopbackUrl(url) {
-  if (typeof url !== "string" || !MCP_LOOPBACK_URL_PATTERN.test(url)) {
-    throw new ModelCliCommandError("MCP bridge URL is not a loopback URL this node produced");
+__name(isFieldRejection, "isFieldRejection");
+
+// src/core/api-base.ts
+var API_URL_ENV = "EVER_WORKS_NODE_API_URL";
+function rawPin(env) {
+  const value = env[API_URL_ENV];
+  if (typeof value !== "string") {
+    return null;
   }
-  return url;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
 }
-__name(assertLoopbackUrl, "assertLoopbackUrl");
-var MCP_SERVER_NAME_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
-var MCP_LOOPBACK_URL_PATTERN = /^http:\/\/127\.0\.0\.1:\d{1,5}\/mcp\/[a-f0-9]{8,64}$/;
-function assertModelId(model) {
-  if (model === void 0) return null;
-  if (!FLEET_AGENT_EXECUTION_MODEL_PATTERN.test(model)) {
-    throw new ModelCliCommandError("Model id is not an opaque identifier");
+__name(rawPin, "rawPin");
+function readApiUrlPin(env = process.env) {
+  const raw = rawPin(env);
+  return raw === null ? null : normalizeApiUrl(raw);
+}
+__name(readApiUrlPin, "readApiUrlPin");
+function resolveApiBase(config, env = process.env) {
+  const configuredUrl = config.apiUrl;
+  const pinnedTo = readApiUrlPin(env);
+  if (pinnedTo === null) {
+    return { url: configuredUrl, source: "config", configuredUrl, pinnedTo: null, mismatch: false };
   }
-  return model;
+  return {
+    url: pinnedTo,
+    source: "pin",
+    configuredUrl,
+    pinnedTo,
+    mismatch: pinnedTo !== configuredUrl
+  };
 }
-__name(assertModelId, "assertModelId");
-var MODEL_CLI_OPTIONAL_FLAGS = {
-  "claude-code": ["--effort", "--max-budget-usd"],
+__name(resolveApiBase, "resolveApiBase");
+function describeApiBase(base) {
+  if (base.source === "config") {
+    return `${base.url} (from the enrolled config)`;
+  }
+  if (!base.mismatch) {
+    return `${base.url} (pinned via ${API_URL_ENV}; matches the enrolled origin)`;
+  }
+  return `${base.url} (PINNED via ${API_URL_ENV}) \u2014 enrolled against ${base.configuredUrl}. The pin does not match the enrolled origin: this node has no credential on the pinned platform, so every call will be refused with 401 until the pin is corrected or the node is re-enrolled.`;
+}
+__name(describeApiBase, "describeApiBase");
+
+// src/core/auth-client.ts
+var EVER_ID_DEVICE_SCOPE = ["openid", "email", EVER_ID_SCOPES.SESSION_EXCHANGE].join(" ");
+
+// src/core/telemetry-probe.ts
+var AGENT_CLI_CANDIDATES = ["claude", "codex", "gemini", "opencode"];
+function parseCliVersion(stdout) {
+  if (typeof stdout !== "string") return null;
+  const match = /\b(\d+\.\d+(?:\.\d+)?(?:[-+][0-9A-Za-z.-]+)?)\b/.exec(stdout);
+  return match ? match[1] : null;
+}
+__name(parseCliVersion, "parseCliVersion");
+async function detectAgentCliVersion(runner, candidates = AGENT_CLI_CANDIDATES) {
+  for (const command of candidates) {
+    try {
+      const result = await runner.run(command, ["--version"]);
+      if (result.code !== 0) continue;
+      const version = parseCliVersion(`${result.stdout ?? ""}
+${result.stderr ?? ""}`);
+      if (!version) continue;
+      return `${command} ${version}`.slice(0, FLEET_MAX_CLI_VERSION_LENGTH);
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+__name(detectAgentCliVersion, "detectAgentCliVersion");
+async function detectDiskFreeBytes(io, path2) {
+  try {
+    const free = await io.freeBytes(path2);
+    if (typeof free !== "number" || !Number.isFinite(free) || free < 0) return null;
+    return Math.floor(free);
+  } catch {
+    return null;
+  }
+}
+__name(detectDiskFreeBytes, "detectDiskFreeBytes");
+var MODEL_IDENTITY_CACHE_TTL_MS = 5 * 6e4;
+function parseClaudeAuthStatus(stdout) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout.trim());
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const status = parsed;
+  if (status.loggedIn !== true) return "claude-code: not logged in";
+  const email = compactString(status.email);
+  const org = compactString(status.orgName);
+  const plan = compactString(status.subscriptionType);
+  const method = compactString(status.authMethod);
+  const who = email ?? (method ? `${method} login` : "logged in");
+  const details = [org, plan].filter((part) => part !== null);
+  return `claude-code: ${who}${details.length > 0 ? ` (${details.join(", ")})` : ""}`;
+}
+__name(parseClaudeAuthStatus, "parseClaudeAuthStatus");
+function parseCodexLoginStatus(stdout) {
+  const text = stdout.trim().toLowerCase();
+  if (!text) return null;
+  if (text.includes("not logged in")) return "codex: not logged in";
+  if (text.includes("chatgpt")) return "codex: chatgpt";
+  if (text.includes("api key")) return "codex: api-key";
+  if (text.includes("logged in")) return "codex: logged in";
+  return null;
+}
+__name(parseCodexLoginStatus, "parseCodexLoginStatus");
+function compactString(value) {
+  if (typeof value !== "string") return null;
+  const cleaned = value.replace(/[\u0000-\u001F\u007F]+/g, " ").trim();
+  return cleaned ? cleaned : null;
+}
+__name(compactString, "compactString");
+async function detectModelIdentity(runner, paths = {}) {
+  const candidates = [
+    { command: paths["claude-code"] || "claude", args: ["auth", "status", "--json"], parse: parseClaudeAuthStatus },
+    { command: paths.codex || "codex", args: ["login", "status"], parse: parseCodexLoginStatus }
+  ];
+  for (const candidate of candidates) {
+    try {
+      const result = await runner.run(candidate.command, candidate.args);
+      const stdout = result.stdout ?? "";
+      const stderr = result.stderr ?? "";
+      const label = candidate.parse(stdout) ?? candidate.parse(`${stdout}
+${stderr}`);
+      if (label) return label.slice(0, FLEET_MAX_MODEL_IDENTITY_LENGTH);
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+__name(detectModelIdentity, "detectModelIdentity");
+function cacheProbe(probe, ttlMs = MODEL_IDENTITY_CACHE_TTL_MS, now = Date.now) {
+  let value = null;
+  let expiresAt = Number.NEGATIVE_INFINITY;
+  let inFlight = null;
+  return async () => {
+    if (now() < expiresAt) return value;
+    if (inFlight) return inFlight;
+    inFlight = probe().then((fresh) => {
+      value = fresh;
+      expiresAt = now() + ttlMs;
+      return fresh;
+    }).finally(() => {
+      inFlight = null;
+    });
+    return inFlight;
+  };
+}
+__name(cacheProbe, "cacheProbe");
+
+// src/core/executors/model-cli.ts
+var MODEL_CLI_EMPTY_MCP_CONFIG = `${JSON.stringify({ mcpServers: {} }, null, 2)}
+`;
+var CODEX_SETTING_VALUE = /^[A-Za-z0-9._-]{1,64}$/;
+var TOML_STRING_ASSIGNMENT = /^([A-Za-z0-9_-]+)[ \t]*=[ \t]*(?:"([^"\\]*)"|'([^']*)')(?:[ \t]+#.*|#.*)?$/;
+var TOML_MULTILINE_VALUE_START = /^[^=#]*=[ \t]*("""|''')/;
+function readCodexUserSettings(configToml) {
+  const settings = {};
+  if (typeof configToml !== "string" || configToml.length === 0) return settings;
+  let table = "";
+  let openMultiline = null;
+  for (const raw of configToml.split(/\r?\n/)) {
+    if (openMultiline !== null) {
+      if (indexOfTomlClosingDelimiter(raw, openMultiline) !== -1) openMultiline = null;
+      continue;
+    }
+    const line = raw.trim();
+    const opening = TOML_MULTILINE_VALUE_START.exec(line);
+    if (opening) {
+      const delimiter = opening[1];
+      if (indexOfTomlClosingDelimiter(line.slice(opening[0].length), delimiter) === -1) {
+        openMultiline = delimiter;
+        continue;
+      }
+    }
+    if (line.startsWith("[")) {
+      if (line.startsWith("[[")) {
+        table = "\0array";
+      } else {
+        const close = line.indexOf("]");
+        table = close > 1 ? line.slice(1, close).trim() : "\0unknown";
+      }
+      continue;
+    }
+    const assignment = TOML_STRING_ASSIGNMENT.exec(line);
+    if (!assignment) continue;
+    const key = assignment[1];
+    const value = assignment[2] ?? assignment[3] ?? "";
+    if (!CODEX_SETTING_VALUE.test(value)) continue;
+    if (table === "" && key === "model" && settings.model === void 0) settings.model = value;
+    else if (table === "" && key === "model_reasoning_effort" && settings.reasoningEffort === void 0) {
+      settings.reasoningEffort = value;
+    } else if (table === "windows" && key === "sandbox" && settings.windowsSandbox === void 0) {
+      settings.windowsSandbox = value;
+    }
+  }
+  return settings;
+}
+__name(readCodexUserSettings, "readCodexUserSettings");
+function indexOfTomlClosingDelimiter(text, delimiter) {
+  let from = 0;
+  for (; ; ) {
+    const at = text.indexOf(delimiter, from);
+    if (at === -1 || delimiter === "'''") return at;
+    let backslashes = 0;
+    for (let i = at - 1; i >= 0 && text[i] === "\\"; i -= 1) backslashes += 1;
+    if (backslashes % 2 === 0) return at;
+    from = at + 1;
+  }
+}
+__name(indexOfTomlClosingDelimiter, "indexOfTomlClosingDelimiter");
+function assertCodexSetting(name, value) {
+  if (value === void 0) return void 0;
+  if (!CODEX_SETTING_VALUE.test(value)) {
+    throw new ModelCliCommandError(`Refusing to forward the Codex setting '${name}': not a bare identifier`);
+  }
+  return value;
+}
+__name(assertCodexSetting, "assertCodexSetting");
+function modelCliMcpIsolationEnv(provider) {
+  return provider === "claude-code" ? { ENABLE_CLAUDEAI_MCP_SERVERS: "false" } : null;
+}
+__name(modelCliMcpIsolationEnv, "modelCliMcpIsolationEnv");
+function claudeManagedMcpConfigPath(platform = process.platform) {
+  if (platform === "win32") return "C:\\Program Files\\ClaudeCode\\managed-mcp.json";
+  if (platform === "darwin") return "/Library/Application Support/ClaudeCode/managed-mcp.json";
+  return "/etc/claude-code/managed-mcp.json";
+}
+__name(claudeManagedMcpConfigPath, "claudeManagedMcpConfigPath");
+function claudeManagedMcpConfigInEffect(raw) {
+  if (typeof raw !== "string" || !raw.trim()) return false;
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed);
+  } catch {
+    return false;
+  }
+}
+__name(claudeManagedMcpConfigInEffect, "claudeManagedMcpConfigInEffect");
+var ModelCliCommandError = class extends Error {
+  static {
+    __name(this, "ModelCliCommandError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "ModelCliCommandError";
+  }
+};
+var MODEL_CLI_STEP_ID = "model";
+var MODEL_CLI_OUTPUT_TAIL_BYTES = 8 * 1024;
+var MODEL_CLI_MAX_OUTPUT_BYTES = 8 * 1024 * 1024;
+var ABSOLUTE_WIN32 = /^[A-Za-z]:[\\/]/;
+var UNSAFE_PATH_CHARS = /[\0\r\n"'`$&|;<>%!^]/;
+function quoteShellPath(path2, platform = process.platform) {
+  if (typeof path2 !== "string" || !path2.trim()) {
+    throw new ModelCliCommandError("Path must not be empty");
+  }
+  if (UNSAFE_PATH_CHARS.test(path2)) {
+    throw new ModelCliCommandError("Path contains characters the shell could interpret");
+  }
+  const absolute = platform === "win32" ? ABSOLUTE_WIN32.test(path2) || path2.startsWith("\\\\") : path2.startsWith("/");
+  if (!absolute) {
+    throw new ModelCliCommandError("Path must be absolute");
+  }
+  return `"${path2}"`;
+}
+__name(quoteShellPath, "quoteShellPath");
+function assertMcpServerName(name) {
+  if (typeof name !== "string" || !MCP_SERVER_NAME_PATTERN.test(name)) {
+    throw new ModelCliCommandError("MCP server name is not an opaque identifier");
+  }
+  return name;
+}
+__name(assertMcpServerName, "assertMcpServerName");
+function assertLoopbackUrl(url) {
+  if (typeof url !== "string" || !MCP_LOOPBACK_URL_PATTERN.test(url)) {
+    throw new ModelCliCommandError("MCP bridge URL is not a loopback URL this node produced");
+  }
+  return url;
+}
+__name(assertLoopbackUrl, "assertLoopbackUrl");
+var MCP_SERVER_NAME_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+var MCP_LOOPBACK_URL_PATTERN = /^http:\/\/127\.0\.0\.1:\d{1,5}\/mcp\/[a-f0-9]{8,64}$/;
+function assertModelId(model) {
+  if (model === void 0) return null;
+  if (!FLEET_AGENT_EXECUTION_MODEL_PATTERN.test(model)) {
+    throw new ModelCliCommandError("Model id is not an opaque identifier");
+  }
+  return model;
+}
+__name(assertModelId, "assertModelId");
+var MODEL_CLI_OPTIONAL_FLAGS = {
+  "claude-code": ["--effort", "--max-budget-usd"],
   codex: []
 };
 function unsupportedOptionalModelCliFlags(execution, supportedFlags) {
@@ -7692,7 +8344,21 @@ function buildModelCliCommand(input) {
     if (roots.length > 0) args.push("--add-dir", ...roots);
   } else if (execution.provider === "codex") {
     const sandbox = permissionMode === "plan" ? "read-only" : "workspace-write";
-    args.push("exec", "--json", "--sandbox", sandbox, "-C", quoteShellPath(input.workspacePath, platform));
+    args.push(
+      "exec",
+      "--ignore-user-config",
+      "--json",
+      "--sandbox",
+      sandbox,
+      "-C",
+      quoteShellPath(input.workspacePath, platform)
+    );
+    const kept = input.codexUserSettings ?? {};
+    const windowsSandbox = assertCodexSetting("windows.sandbox", kept.windowsSandbox);
+    const reasoningEffort = assertCodexSetting("model_reasoning_effort", kept.reasoningEffort);
+    const ownerModel = assertCodexSetting("model", kept.model);
+    if (windowsSandbox) args.push("-c", `windows.sandbox=${windowsSandbox}`);
+    if (reasoningEffort) args.push("-c", `model_reasoning_effort=${reasoningEffort}`);
     if (sandbox === "workspace-write") {
       for (const root of grantedRoots(writableMounts)) args.push("--add-dir", root);
     }
@@ -7702,7 +8368,8 @@ function buildModelCliCommand(input) {
         `mcp_servers.${assertMcpServerName(mcp.serverName)}.url=${assertLoopbackUrl(mcp.serverUrl)}`
       );
     }
-    if (model) args.push("-m", model);
+    const codexModel = model ?? ownerModel;
+    if (codexModel) args.push("-m", codexModel);
     if (execution.skipPermissions === true) args.push("--dangerously-bypass-approvals-and-sandbox");
     args.push("-");
   } else {
@@ -7725,7 +8392,16 @@ function assertMountGrantsInCommand(input) {
 }
 __name(assertMountGrantsInCommand, "assertMountGrantsInCommand");
 var STRICT_MCP_CONFIG_IN_COMMAND = / --mcp-config "[^"]+" --strict-mcp-config /;
+var CODEX_IGNORE_USER_CONFIG_IN_COMMAND = / exec --ignore-user-config /;
 function assertMcpIsolationInCommand(input) {
+  if (input.execution.provider === "codex") {
+    if (!CODEX_IGNORE_USER_CONFIG_IN_COMMAND.test(input.command)) {
+      throw new ModelCliCommandError(
+        "The codex command line does not carry exec --ignore-user-config, so the run would load the machine owner's own config.toml: its MCP servers, plugins and notify hook"
+      );
+    }
+    return;
+  }
   if (input.execution.provider !== "claude-code") return;
   if (!STRICT_MCP_CONFIG_IN_COMMAND.test(input.command)) {
     throw new ModelCliCommandError(
@@ -8053,7 +8729,7 @@ var MODEL_CLI_REQUIRED_FLAGS = {
   // bridge's. A CLI without them cannot run fleet work at all, so `doctor`
   // must say INCOMPATIBLE, not "runs that need them will fail".
   "claude-code": ["-p", "--output-format", "--permission-mode", "--mcp-config", "--strict-mcp-config"],
-  codex: ["--json", "--sandbox", "-C"]
+  codex: ["--json", "--sandbox", "-C", "--ignore-user-config"]
 };
 var MODEL_CLI_CONDITIONAL_FLAGS = {
   "claude-code": [
@@ -8099,390 +8775,137 @@ var ModelCliCompatibilityProbe = class {
     const pending = this.inFlight.get(key);
     if (pending) return pending;
     const run = this.run(provider, executable).then(({ result, answered }) => {
-      this.cache.set(`${provider}|${executable}`, {
-        key,
-        // A COMPLETE answer from a stamped file is kept until the file
-        // changes or, at the latest, for `stampedMaxAgeMs` (an upgrade
-        // behind a stable wrapper does not change the stamp). An
-        // incomplete one is retried soon, and an unstamped one on the
-        // ten-minute clock.
-        ttlMs: !answered ? this.incompleteRetryMs : stamp !== null ? this.stampedMaxAgeMs : this.unstampedTtlMs,
-        probedAt: this.now(),
-        result
-      });
-      return result;
-    }).finally(() => {
-      this.inFlight.delete(key);
-    });
-    this.inFlight.set(key, run);
-    return run;
-  }
-  /** Every pinned binary in `paths`, in provider order. Unpinned providers are skipped. */
-  async probeAll(paths) {
-    const out = [];
-    for (const provider of MODEL_CLI_PROVIDERS) {
-      const executable = paths?.[provider];
-      if (typeof executable !== "string" || !executable.trim()) continue;
-      out.push(await this.probe(provider, executable));
-    }
-    return out;
-  }
-  async stamp(executable) {
-    if (!this.options.statFile) return null;
-    try {
-      const stamp = await this.options.statFile(executable);
-      return stamp && Number.isFinite(stamp.mtimeMs) && Number.isFinite(stamp.size) ? stamp : null;
-    } catch {
-      return null;
-    }
-  }
-  async run(provider, executable) {
-    const command = this.commandFor(executable);
-    const versionOutput = await this.ask(command, ["--version"]);
-    const version = versionOutput === null ? null : parseCliVersion(versionOutput);
-    const help = await this.ask(command, [...HELP_ARGS[provider]]);
-    return {
-      result: judgeModelCliHelp(provider, executable, version, help),
-      // "Answered" = both invocations produced output. An UNRECOGNISED
-      // help text is still an answer — deterministic for that file — and
-      // re-asking every minute would learn nothing.
-      answered: versionOutput !== null && help !== null
-    };
-  }
-  /**
-   * The runner on Windows goes through `cmd.exe` (`shell: true`), which
-   * splits an unquoted `C:\Program Files\…` at the space.
-   */
-  commandFor(executable) {
-    return this.options.platform === "win32" && /\s/.test(executable) && !executable.startsWith('"') ? `"${executable}"` : executable;
-  }
-  /** stdout+stderr of one invocation, or null when it could not be run at all. */
-  async ask(command, args) {
-    try {
-      const result = await this.options.runner.run(command, args);
-      if (result.timedOut) return null;
-      const text = `${result.stdout ?? ""}
-${result.stderr ?? ""}`;
-      return result.code === 0 || text.trim() ? text : null;
-    } catch {
-      return null;
-    }
-  }
-};
-function parseAdvertisedFlags(help) {
-  const flags = /* @__PURE__ */ new Set();
-  const pattern = /(?:^|[\s,[(|])(--?[A-Za-z][A-Za-z0-9-]*)(?=$|[\s,=<[\])|.:])/gm;
-  for (const match of help.matchAll(pattern)) {
-    flags.add(match[1]);
-  }
-  return flags;
-}
-__name(parseAdvertisedFlags, "parseAdvertisedFlags");
-function judgeModelCliHelp(provider, executable, version, help) {
-  const required = MODEL_CLI_REQUIRED_FLAGS[provider];
-  const base = {
-    provider,
-    executable,
-    version,
-    supportedFlags: null,
-    missingRequiredFlags: [],
-    missingConditionalFlags: [],
-    unsupportedOptionalFlags: [],
-    note: null
-  };
-  if (help === null) {
-    return { ...base, note: "the binary did not answer --help; nothing is dropped" };
-  }
-  const advertised = parseAdvertisedFlags(help);
-  if (!required.some((flag) => advertised.has(flag))) {
-    return {
-      ...base,
-      note: `the help text lists none of the flags this node always passes (${required.join(", ")}); its format is not recognised, so nothing is dropped`
-    };
-  }
-  const missing = /* @__PURE__ */ __name((list) => list.filter((flag) => !advertised.has(flag)), "missing");
-  return {
-    ...base,
-    supportedFlags: advertised,
-    missingRequiredFlags: missing(required),
-    missingConditionalFlags: missing(MODEL_CLI_CONDITIONAL_FLAGS[provider]),
-    unsupportedOptionalFlags: missing(MODEL_CLI_OPTIONAL_FLAGS[provider])
-  };
-}
-__name(judgeModelCliHelp, "judgeModelCliHelp");
-function isModelCliCompatible(compat) {
-  return compat.missingRequiredFlags.length === 0;
-}
-__name(isModelCliCompatible, "isModelCliCompatible");
-function describeCliVersions(results) {
-  return results.map((result) => `${result.provider} ${result.version ?? "unknown"}`.slice(0, FLEET_MAX_CLI_VERSION_LENGTH)).slice(0, FLEET_MAX_CLI_VERSIONS);
-}
-__name(describeCliVersions, "describeCliVersions");
-var LEGACY_COMMAND_NAME = {
-  "claude-code": "claude",
-  codex: "codex"
-};
-function primaryPinnedCliVersion(results) {
-  const first = results.find((result) => result.version !== null);
-  return first ? `${LEGACY_COMMAND_NAME[first.provider]} ${first.version}`.slice(0, FLEET_MAX_CLI_VERSION_LENGTH) : null;
-}
-__name(primaryPinnedCliVersion, "primaryPinnedCliVersion");
-
-// src/core/worker-loop.ts
-var import_node_perf_hooks = require("node:perf_hooks");
-
-// src/core/heartbeat.ts
-var systemScheduler = {
-  setTimeout: /* @__PURE__ */ __name((callback, ms) => setTimeout(callback, ms), "setTimeout"),
-  clearTimeout: /* @__PURE__ */ __name((handle) => clearTimeout(handle), "clearTimeout")
-};
-var OPTIONAL_DESCRIPTION_FIELD_TIERS = [
-  // NEWEST first. Node lifecycle + remote node limits (self-build slices
-  // AR, AS). Tiered (review): `cliVersions` goes out on EVERY beat of a
-  // node with a pinned CLI, so an upgraded node talking to a platform that
-  // predates it would otherwise drop the worker state and housekeeping
-  // along with it — losing health signals that platform DOES understand,
-  // for the life of the process. Stripping the newest tier first keeps them.
-  ["cliVersions", "maxConcurrentJobs", "maxCpuPercent", "maxMemoryMb"],
-  // Fleet health signals (EW-776) and node housekeeping (EW-803).
-  [
-    "workerState",
-    "workerStateReason",
-    "minFreeDiskBytes",
-    "workspaceCount",
-    "workspaceBytes",
-    "lastReclaimAt",
-    "lastReclaimFreedBytes"
-  ]
-];
-function computeBackoffDelay(intervalMs, failures, maxMs) {
-  if (failures <= 0) {
-    return intervalMs;
-  }
-  const exponent = Math.min(failures, 30);
-  const delay2 = intervalMs * 2 ** exponent;
-  return Math.min(delay2, maxMs);
-}
-__name(computeBackoffDelay, "computeBackoffDelay");
-var HeartbeatLoop = class {
-  static {
-    __name(this, "HeartbeatLoop");
-  }
-  options;
-  scheduler;
-  now;
-  listeners = /* @__PURE__ */ new Set();
-  timer = null;
-  running = false;
-  inFlight = null;
-  /**
-   * How many optional-field TIERS (newest first) this platform has proven
-   * it predates; from then on the beat leaves those tiers out. 0 = it
-   * takes everything. Process-scoped on purpose — a platform upgrade is a
-   * restart-shaped event for the node, and re-probing on every beat would
-   * mean one wasted round trip per beat, forever, against an API that
-   * will never accept them.
-   */
-  strippedTiers = 0;
-  state = {
-    state: "idle",
-    lastHeartbeatAt: null,
-    consecutiveFailures: 0,
-    nextAttemptInMs: null,
-    lastError: null,
-    lastErrorKind: null,
-    node: null
-  };
-  constructor(options) {
-    this.options = {
-      ...options,
-      intervalMs: options.intervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS,
-      maxBackoffMs: options.maxBackoffMs ?? MAX_HEARTBEAT_BACKOFF_MS
-    };
-    this.scheduler = options.scheduler ?? systemScheduler;
-    this.now = options.now ?? (() => Date.now());
-    this.options.logger?.protect(options.secret);
-  }
-  getState() {
-    return { ...this.state };
-  }
-  onChange(listener) {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  /** Start beating. Resolves once the FIRST beat has settled. */
-  start() {
-    if (this.running) {
-      return this.inFlight ?? Promise.resolve();
-    }
-    this.running = true;
-    return this.tick();
-  }
-  /** Stop beating and cancel any pending timer. */
-  stop() {
-    this.running = false;
-    this.cancelTimer();
-    this.patch({ state: "stopped", nextAttemptInMs: null });
-  }
-  /** Await the in-flight beat, if any (test/shutdown helper). */
-  async settled() {
-    await this.inFlight;
-  }
-  /** Run one beat now. Exposed so the UI can offer "retry" and tests can step. */
-  tick() {
-    const run = this.runOnce().finally(() => {
-      if (this.inFlight === run) {
-        this.inFlight = null;
-      }
-    });
-    this.inFlight = run;
-    return run;
-  }
-  async runOnce() {
-    if (!this.running) {
-      return;
-    }
-    this.cancelTimer();
-    if (this.state.state !== "connected") {
-      this.patch({ state: "connecting" });
-    }
-    try {
-      const description = await this.options.describe();
-      this.onSuccess(await this.beat(description));
-    } catch (error) {
-      this.onFailure(error);
-    }
-    this.scheduleNext();
-  }
-  /**
-   * Send one beat, tolerating a platform that predates the optional
-   * self-description fields (the worker state, EW-776; the housekeeping
-   * report, EW-803).
-   *
-   * The API validates heartbeats with `whitelist + forbidNonWhitelisted`,
-   * so a field an older build does not know is not ignored — it 400s the
-   * whole request. A 400 is a FAILED beat, a failed beat backs off, and
-   * enough of them sweep the node to `offline`. Which would mean shipping
-   * a health-reporting feature whose failure mode is "every node in a
-   * mixed-version fleet goes dark": the exact class of outage this slice
-   * was written to end.
-   *
-   * So a 400 on a beat that CARRIED those fields is retried once,
-   * immediately, without them. If that succeeds the platform is simply
-   * older than this daemon; we latch, say so once, and keep reporting
-   * liveness. The retry costs one request, once per process.
-   *
-   * Inferring "the field was rejected" from a bare 400 is deliberate and
-   * has a cost worth stating: `FleetClient` never surfaces server bodies
-   * (fixed client-authored messages only), so a 400 caused by something
-   * else on such a beat also latches, and this node reports liveness only
-   * until it restarts. That is the safe direction — the node stays
-   * observable either way, and only the extra signal is lost.
-   */
-  async beat(description) {
-    const credential = { nodeId: this.options.nodeId, secret: this.options.secret };
-    let sent = stripTiers(description, this.strippedTiers);
-    try {
-      return await this.options.client.heartbeat({ ...credential, ...sent });
-    } catch (error) {
-      if (!isFieldRejection(error)) throw error;
-      let lastError = error;
-      for (let tiers = this.strippedTiers + 1; tiers <= OPTIONAL_DESCRIPTION_FIELD_TIERS.length; tiers += 1) {
-        const candidate = stripTiers(description, tiers);
-        if (Object.keys(candidate).length === Object.keys(sent).length) continue;
-        sent = candidate;
-        try {
-          const result = await this.options.client.heartbeat({ ...credential, ...candidate });
-          this.strippedTiers = tiers;
-          this.options.logger?.warn(
-            tiers >= OPTIONAL_DESCRIPTION_FIELD_TIERS.length ? "Platform rejected the optional self-description fields (worker state, housekeeping); it predates them. Reporting liveness only until this node restarts." : "Platform rejected the newest optional self-description fields (pinned CLI versions, enforced limits); it predates them. Still reporting worker state and housekeeping; the newer fields stay off until this node restarts."
-          );
-          return result;
-        } catch (retryError) {
-          if (!isFieldRejection(retryError)) throw retryError;
-          lastError = retryError;
-        }
-      }
-      throw lastError;
-    }
-  }
-  onSuccess(result) {
-    this.patch({
-      state: "connected",
-      lastHeartbeatAt: this.now(),
-      consecutiveFailures: 0,
-      lastError: null,
-      lastErrorKind: null,
-      node: result.node
-    });
-    if (this.options.onAccepted) {
-      try {
-        this.options.onAccepted(result);
-      } catch {
-      }
-    }
-  }
-  onFailure(error) {
-    const kind = error instanceof FleetClientError ? error.kind : "network";
-    const raw = error instanceof Error ? error.message : String(error);
-    const message = this.options.logger?.redact(raw) ?? raw;
-    const failures = this.state.consecutiveFailures + 1;
-    this.patch({
-      // `unauthorized` is sticky and visible: the operator has to act
-      // (re-enable the node in Fleet, or re-enroll). We keep retrying at
-      // the backoff ceiling so a re-enabled node recovers on its own.
-      state: kind === "unauthorized" ? "unauthorized" : "retrying",
-      consecutiveFailures: failures,
-      lastError: message,
-      lastErrorKind: kind
+      this.cache.set(`${provider}|${executable}`, {
+        key,
+        // A COMPLETE answer from a stamped file is kept until the file
+        // changes or, at the latest, for `stampedMaxAgeMs` (an upgrade
+        // behind a stable wrapper does not change the stamp). An
+        // incomplete one is retried soon, and an unstamped one on the
+        // ten-minute clock.
+        ttlMs: !answered ? this.incompleteRetryMs : stamp !== null ? this.stampedMaxAgeMs : this.unstampedTtlMs,
+        probedAt: this.now(),
+        result
+      });
+      return result;
+    }).finally(() => {
+      this.inFlight.delete(key);
     });
-    this.options.logger?.warn(`Heartbeat failed (attempt ${failures}): ${message}`);
+    this.inFlight.set(key, run);
+    return run;
   }
-  scheduleNext() {
-    if (!this.running) {
-      return;
+  /** Every pinned binary in `paths`, in provider order. Unpinned providers are skipped. */
+  async probeAll(paths) {
+    const out = [];
+    for (const provider of MODEL_CLI_PROVIDERS) {
+      const executable = paths?.[provider];
+      if (typeof executable !== "string" || !executable.trim()) continue;
+      out.push(await this.probe(provider, executable));
     }
-    const delay2 = computeBackoffDelay(
-      this.options.intervalMs,
-      this.state.consecutiveFailures,
-      this.options.maxBackoffMs
-    );
-    this.patch({ nextAttemptInMs: delay2 });
-    this.timer = this.scheduler.setTimeout(() => {
-      this.timer = null;
-      void this.tick();
-    }, delay2);
+    return out;
   }
-  cancelTimer() {
-    if (this.timer !== null) {
-      this.scheduler.clearTimeout(this.timer);
-      this.timer = null;
+  async stamp(executable) {
+    if (!this.options.statFile) return null;
+    try {
+      const stamp = await this.options.statFile(executable);
+      return stamp && Number.isFinite(stamp.mtimeMs) && Number.isFinite(stamp.size) ? stamp : null;
+    } catch {
+      return null;
     }
   }
-  patch(next) {
-    this.state = { ...this.state, ...next };
-    const snapshot = this.getState();
-    for (const listener of this.listeners) {
-      listener(snapshot);
+  async run(provider, executable) {
+    const command = this.commandFor(executable);
+    const versionOutput = await this.ask(command, ["--version"]);
+    const version = versionOutput === null ? null : parseCliVersion(versionOutput);
+    const help = await this.ask(command, [...HELP_ARGS[provider]]);
+    return {
+      result: judgeModelCliHelp(provider, executable, version, help),
+      // "Answered" = both invocations produced output. An UNRECOGNISED
+      // help text is still an answer — deterministic for that file — and
+      // re-asking every minute would learn nothing.
+      answered: versionOutput !== null && help !== null
+    };
+  }
+  /**
+   * The runner on Windows goes through `cmd.exe` (`shell: true`), which
+   * splits an unquoted `C:\Program Files\…` at the space.
+   */
+  commandFor(executable) {
+    return this.options.platform === "win32" && /\s/.test(executable) && !executable.startsWith('"') ? `"${executable}"` : executable;
+  }
+  /** stdout+stderr of one invocation, or null when it could not be run at all. */
+  async ask(command, args) {
+    try {
+      const result = await this.options.runner.run(command, args);
+      if (result.timedOut) return null;
+      const text = `${result.stdout ?? ""}
+${result.stderr ?? ""}`;
+      return result.code === 0 || text.trim() ? text : null;
+    } catch {
+      return null;
     }
   }
 };
-function stripTiers(description, tiers) {
-  const out = {};
-  const dropped = new Set(OPTIONAL_DESCRIPTION_FIELD_TIERS.slice(0, tiers).flat());
-  for (const [key, value] of Object.entries(description)) {
-    if (value === void 0 || dropped.has(key)) continue;
-    out[key] = value;
+function parseAdvertisedFlags(help) {
+  const flags = /* @__PURE__ */ new Set();
+  const pattern = /(?:^|[\s,[(|])(--?[A-Za-z][A-Za-z0-9-]*)(?=$|[\s,=<[\])|.:])/gm;
+  for (const match of help.matchAll(pattern)) {
+    flags.add(match[1]);
   }
-  return out;
+  return flags;
 }
-__name(stripTiers, "stripTiers");
-function isFieldRejection(error) {
-  return error instanceof FleetClientError && error.kind === "invalid-request" && error.status === 400;
+__name(parseAdvertisedFlags, "parseAdvertisedFlags");
+function judgeModelCliHelp(provider, executable, version, help) {
+  const required = MODEL_CLI_REQUIRED_FLAGS[provider];
+  const base = {
+    provider,
+    executable,
+    version,
+    supportedFlags: null,
+    missingRequiredFlags: [],
+    missingConditionalFlags: [],
+    unsupportedOptionalFlags: [],
+    note: null
+  };
+  if (help === null) {
+    return { ...base, note: "the binary did not answer --help; nothing is dropped" };
+  }
+  const advertised = parseAdvertisedFlags(help);
+  if (!required.some((flag) => advertised.has(flag))) {
+    return {
+      ...base,
+      note: `the help text lists none of the flags this node always passes (${required.join(", ")}); its format is not recognised, so nothing is dropped`
+    };
+  }
+  const missing = /* @__PURE__ */ __name((list) => list.filter((flag) => !advertised.has(flag)), "missing");
+  return {
+    ...base,
+    supportedFlags: advertised,
+    missingRequiredFlags: missing(required),
+    missingConditionalFlags: missing(MODEL_CLI_CONDITIONAL_FLAGS[provider]),
+    unsupportedOptionalFlags: missing(MODEL_CLI_OPTIONAL_FLAGS[provider])
+  };
 }
-__name(isFieldRejection, "isFieldRejection");
+__name(judgeModelCliHelp, "judgeModelCliHelp");
+function isModelCliCompatible(compat) {
+  return compat.missingRequiredFlags.length === 0;
+}
+__name(isModelCliCompatible, "isModelCliCompatible");
+function describeCliVersions(results) {
+  return results.map((result) => `${result.provider} ${result.version ?? "unknown"}`.slice(0, FLEET_MAX_CLI_VERSION_LENGTH)).slice(0, FLEET_MAX_CLI_VERSIONS);
+}
+__name(describeCliVersions, "describeCliVersions");
+var LEGACY_COMMAND_NAME = {
+  "claude-code": "claude",
+  codex: "codex"
+};
+function primaryPinnedCliVersion(results) {
+  const first = results.find((result) => result.version !== null);
+  return first ? `${LEGACY_COMMAND_NAME[first.provider]} ${first.version}`.slice(0, FLEET_MAX_CLI_VERSION_LENGTH) : null;
+}
+__name(primaryPinnedCliVersion, "primaryPinnedCliVersion");
+
+// src/core/worker-loop.ts
+var import_node_perf_hooks = require("node:perf_hooks");
 
 // src/core/resource-limits.ts
 var ADMIT = { admit: true, reason: null };
@@ -8577,6 +9000,7 @@ __name(measureWorkspaceFreeBytes, "measureWorkspaceFreeBytes");
 
 // src/core/worker-loop.ts
 var DEFAULT_IDLE_POLL_MS = 5e3;
+var MODEL_THROTTLE_SYNC_GRACE_MS = 12e4;
 var WORKER_BACKOFF_BASE_MS = 1e3;
 var WORKER_BACKOFF_MAX_MS = 6e4;
 var MIN_KEEPALIVE_MS = 5e3;
@@ -8675,6 +9099,8 @@ var WorkerLoop = class {
   monotonicNow;
   leasePollDrainTimeoutMs;
   publishFenceMarginMs;
+  /** Fleet usage limits: provider → the throttle in force (expiry checked on read). */
+  modelThrottles = /* @__PURE__ */ new Map();
   running = false;
   stopping = false;
   paused = false;
@@ -8734,7 +9160,118 @@ var WorkerLoop = class {
     return [...this.executors.keys()];
   }
   getState() {
-    return { ...this.state, activeJobIds: [...this.state.activeJobIds] };
+    const modelThrottles = this.activeModelThrottles();
+    return {
+      ...this.state,
+      activeJobIds: [...this.state.activeJobIds],
+      ...modelThrottles.length > 0 ? { modelThrottles } : {}
+    };
+  }
+  /**
+   * Fleet usage limits — record that `limit.provider` is out of quota on this
+   * machine until `limit.retryAfter`. From the next poll the loop leases no
+   * `agent-task` for that CLI (all of `agent-task` when every CLI this node
+   * has is out), and refuses — without starting it — any such job the
+   * platform still hands it. Other job kinds keep leasing. A later reset
+   * replaces an earlier one; an earlier one never shortens a later one.
+   */
+  noteModelUsageLimit(limit) {
+    const provider = typeof limit.provider === "string" ? limit.provider.trim() : "";
+    const until = Date.parse(limit.retryAfter);
+    if (!provider || !Number.isFinite(until) || until <= this.now()) return;
+    const previous = this.modelThrottles.get(provider);
+    if (previous && previous.until >= until) return;
+    this.modelThrottles.set(provider, { until, window: limit.window, reason: limit.message, setAt: this.now() });
+    if (!previous || previous.until <= this.now()) {
+      this.options.logger?.warn(
+        `${describeFleetModelProvider(provider)} hit its ${describeFleetModelUsageLimitWindow(limit.window)} on this node \u2014 not leasing ${provider} agent-task jobs until ${new Date(until).toISOString()} (other work still runs)`
+      );
+    }
+    this.patch({});
+  }
+  /**
+   * Fleet usage limits — reconcile with the platform's view of this node's
+   * throttles, as carried on every heartbeat response (`node.modelThrottles`).
+   *
+   * The platform is authoritative both ways:
+   *  - a throttle it holds that this loop does not (a restarted daemon, a
+   *    limit another path recorded) is ADOPTED, so the node stops offering
+   *    itself for that CLI and says so on its next beat;
+   *  - a throttle this loop holds that the platform no longer does — the
+   *    owner pressed "clear limit now" — is LIFTED, but only once it is older
+   *    than `graceMs`: a heartbeat answered just before the platform recorded
+   *    the limit this node just reported must not undo it.
+   * `null` / absent (an API older than the field) changes nothing.
+   */
+  syncModelThrottles(server, graceMs = MODEL_THROTTLE_SYNC_GRACE_MS) {
+    if (!Array.isArray(server)) return;
+    const now = this.now();
+    const held = /* @__PURE__ */ new Set();
+    let changed = false;
+    for (const entry of server) {
+      const provider = typeof entry?.provider === "string" ? entry.provider.trim() : "";
+      const until = typeof entry?.until === "string" ? Date.parse(entry.until) : Number.NaN;
+      if (!provider || !Number.isFinite(until) || until <= now) continue;
+      held.add(provider);
+      const local = this.modelThrottles.get(provider);
+      if (local && local.until >= until) continue;
+      const window = typeof entry.window === "string" ? entry.window : "usage";
+      const reason = typeof entry.reason === "string" ? entry.reason : `${provider} usage limit reached`;
+      this.modelThrottles.set(provider, { until, window, reason, setAt: local?.setAt ?? now });
+      changed = true;
+      if (!local) {
+        this.options.logger?.info(
+          `${describeFleetModelProvider(provider)} is out of quota on this node per the platform \u2014 not leasing ${provider} agent-task jobs until ${new Date(until).toISOString()}`
+        );
+      }
+    }
+    for (const [provider, local] of this.modelThrottles) {
+      if (held.has(provider) || now - local.setAt < graceMs) continue;
+      this.modelThrottles.delete(provider);
+      changed = true;
+      this.options.logger?.info(
+        `${describeFleetModelProvider(provider)} usage limit was cleared on the platform \u2014 leasing ${provider} agent-task jobs again`
+      );
+    }
+    if (changed) {
+      this.patch({});
+      this.pollSoon();
+    }
+  }
+  /** The usage-limit throttles still in force; expired ones are dropped (and logged) here. */
+  activeModelThrottles() {
+    const now = this.now();
+    const active = [];
+    for (const [provider, throttle] of this.modelThrottles) {
+      if (throttle.until <= now) {
+        this.modelThrottles.delete(provider);
+        this.options.logger?.info(
+          `${describeFleetModelProvider(provider)} usage limit has reset \u2014 leasing ${provider} agent-task jobs again`
+        );
+        continue;
+      }
+      active.push({
+        provider,
+        window: throttle.window,
+        until: new Date(throttle.until).toISOString(),
+        reason: throttle.reason
+      });
+    }
+    return active.sort((a, b) => a.provider.localeCompare(b.provider));
+  }
+  /** True when every model CLI this node can run an agent-task with is out of quota. */
+  allAgentCliThrottled() {
+    const active = this.activeModelThrottles();
+    if (active.length === 0) return false;
+    let providers = [];
+    try {
+      providers = this.options.modelProviders?.() ?? [];
+    } catch {
+      providers = [];
+    }
+    if (providers.length === 0) return true;
+    const out = new Set(active.map((throttle) => throttle.provider));
+    return providers.every((provider) => out.has(provider));
   }
   onChange(listener) {
     this.listeners.add(listener);
@@ -9012,8 +9549,10 @@ var WorkerLoop = class {
       };
       if (this.options.capabilities) request.capabilities = this.options.capabilities;
       if (this.options.kinds && this.options.kinds.length > 0) request.kinds = [...this.options.kinds];
-      if (this.options.excludeKinds && this.options.excludeKinds.length > 0) {
-        request.excludeKinds = [...this.options.excludeKinds];
+      const excludeKinds = new Set(this.options.excludeKinds ?? []);
+      if (this.allAgentCliThrottled()) excludeKinds.add("agent-task");
+      if (excludeKinds.size > 0) {
+        request.excludeKinds = [...excludeKinds];
       }
       if (this.options.client.leaseOutcome) {
         const outcome = await this.options.client.leaseOutcome(request, pollController.signal);
@@ -9250,6 +9789,14 @@ var WorkerLoop = class {
       );
       return;
     }
+    const throttled = this.throttledResultFor(job);
+    if (throttled) {
+      this.options.logger?.info(
+        `Fleet job ${job.id} not started: ${String(throttled.failureReason)} \u2014 handed back for the platform to park`
+      );
+      await this.report(job.id, { success: true, result: throttled }, generation, run);
+      return;
+    }
     const keepAlive = this.startKeepAlive(run);
     let successAccepted = false;
     try {
@@ -9258,6 +9805,7 @@ var WorkerLoop = class {
       );
       const result = await executor(job, signal, keepAlive.handle);
       throwIfJobAborted(signal);
+      this.noteUsageLimitResult(result);
       if (this.settleDeferred(job.id, keepAlive.deferral())) return;
       const accepted = await this.report(
         job.id,
@@ -9292,6 +9840,57 @@ var WorkerLoop = class {
       keepAlive.stop();
     }
   }
+  /** A result that says its CLI hit a usage limit throttles that CLI here. */
+  noteUsageLimitResult(result) {
+    if (!result || result.failureKind !== FLEET_JOB_FAILURE_KIND_MODEL_USAGE_LIMIT) return;
+    const limit = result.modelUsageLimit;
+    if (!limit || typeof limit.provider !== "string" || typeof limit.retryAfter !== "string") return;
+    this.noteModelUsageLimit({
+      provider: limit.provider,
+      window: limit.window ?? "usage",
+      retryAfter: limit.retryAfter,
+      message: typeof limit.message === "string" ? limit.message : `${limit.provider} usage limit reached`
+    });
+  }
+  /**
+   * The usage-limit outcome for an `agent-task` whose CLI is out of quota on
+   * this node, or null. Shaped like a real run's result (model block
+   * included) so the platform — current or older — reads it the same way.
+   */
+  throttledResultFor(job) {
+    if (job.kind !== "agent-task") return null;
+    const payload = job.payload ?? {};
+    const execution = payload.execution;
+    const provider = typeof execution?.provider === "string" ? execution.provider : null;
+    if (!provider) return null;
+    const throttle = this.activeModelThrottles().find((entry) => entry.provider === provider);
+    if (!throttle) return null;
+    const failureReason = `${provider} is out of quota on this node until ${throttle.until} (${describeFleetModelUsageLimitWindow(throttle.window)}) \u2014 not started`;
+    return {
+      status: "failed",
+      taskId: typeof payload.taskId === "string" ? payload.taskId : "",
+      runId: typeof payload.runId === "string" ? payload.runId : null,
+      workspace: null,
+      steps: [],
+      model: {
+        provider,
+        status: "failed",
+        exitCode: null,
+        durationMs: 0,
+        summary: throttle.reason
+      },
+      gateStatus: "none",
+      failureReason,
+      failureKind: FLEET_JOB_FAILURE_KIND_MODEL_USAGE_LIMIT,
+      modelUsageLimit: {
+        provider,
+        window: throttle.window,
+        resetsAt: null,
+        retryAfter: throttle.until,
+        message: throttle.reason
+      }
+    };
+  }
   /**
    * Record a job the executor handed back UNSETTLED, and report nothing.
    *
@@ -10882,6 +11481,32 @@ __name(isReportableBytes, "isReportableBytes");
 // src/core/worker-health.ts
 function describeWorkerHealth(state) {
   if (!state) return null;
+  const projected = projectWorkerState(state);
+  const usage = describeModelThrottles(state);
+  if (!usage) return projected;
+  switch (projected.workerState) {
+    case "idle":
+      return health("throttled", usage);
+    case "throttled":
+    case "working":
+      return health(
+        projected.workerState,
+        projected.workerStateReason ? `${projected.workerStateReason}; ${usage}` : usage
+      );
+    default:
+      return projected;
+  }
+}
+__name(describeWorkerHealth, "describeWorkerHealth");
+function describeModelThrottles(state) {
+  const throttles = state.modelThrottles ?? [];
+  if (throttles.length === 0) return null;
+  return throttles.map(
+    (throttle) => `${throttle.provider}: ${describeFleetModelUsageLimitWindow(throttle.window)} until ${throttle.until}`
+  ).join("; ");
+}
+__name(describeModelThrottles, "describeModelThrottles");
+function projectWorkerState(state) {
   switch (state.state) {
     // The fail-closed stop. `lastError` carries the quarantine's own
     // message (`markUnsafe` writes it there), which is the single most
@@ -10911,7 +11536,7 @@ function describeWorkerHealth(state) {
       return health("idle", null);
   }
 }
-__name(describeWorkerHealth, "describeWorkerHealth");
+__name(projectWorkerState, "projectWorkerState");
 function health(workerState, reason) {
   const trimmed = typeof reason === "string" ? reason.trim() : "";
   if (!trimmed) {
@@ -12871,6 +13496,31 @@ async function runResolvedAgentTask(context, io, signal) {
     containment = modelStep.containment;
     throwIfAgentTaskAborted(signal);
     if (model.status !== "succeeded") {
+      const usageLimit = recognizeModelUsageLimit(model, io);
+      if (usageLimit) {
+        if (workspaceResolution.descriptor && io.removeRunEnvFiles) {
+          await io.removeRunEnvFiles(taskId, workspaceResolution.descriptor).catch(() => void 0);
+        }
+        io.logger?.warn(
+          `[fleet-node] job ${job.id}: ${model.provider} hit a usage limit (${usageLimit.window}) \u2014 retry after ${usageLimit.retryAfter}; steps, checks and publish skipped`
+        );
+        return fitNodeOutcomeToResultBudget({
+          status: "failed",
+          taskId,
+          runId,
+          workspace: workspaceResolution.descriptor,
+          steps: [],
+          ...setupResults.length > 0 ? { setup: setupResults } : {},
+          ...setup.length > 0 ? { setupStatus } : {},
+          model,
+          gateStatus: "none",
+          ...mcp ? { mcp } : {},
+          ...containment ? { containment } : {},
+          failureReason: `${describeModelFailure(model)} \u2014 usage limit, retry after ${usageLimit.retryAfter}`,
+          failureKind: FLEET_JOB_FAILURE_KIND_MODEL_USAGE_LIMIT,
+          modelUsageLimit: usageLimit
+        });
+      }
       failures.push(describeModelFailure(model));
     }
   }
@@ -13096,6 +13746,11 @@ async function runModelStep(jobId, execution, workspacePath, mounts, bridgeSpec,
       emptyMcpConfigPath = mcpConfigPath;
     }
     const droppedFlags = await optionalFlagsToDrop(jobId, execution, executable, io);
+    const codexUserSettings = execution.provider === "codex" ? await readOwnerCodexSettings(
+      jobId,
+      io,
+      effectiveCodexHome(io, modelEnvOverlay, execution.envPassthrough, execution.envGrants)
+    ) : void 0;
     const invoke = /* @__PURE__ */ __name(async (instructions, resumeSessionId) => {
       await scratchFs.writeFile(scratch.instructionsPath, instructions);
       let command;
@@ -13108,6 +13763,7 @@ async function runModelStep(jobId, execution, workspacePath, mounts, bridgeSpec,
           ...mounts && mounts.length > 0 ? { mounts } : {},
           ...bridge.cli ? { mcp: bridge.cli } : {},
           ...emptyMcpConfigPath ? { emptyMcpConfigPath } : {},
+          ...codexUserSettings ? { codexUserSettings } : {},
           ...resumeSessionId ? { resumeSessionId } : {},
           ...io.platform ? { platform: io.platform } : {},
           ...streamClaude ? { stream: true } : {},
@@ -13326,6 +13982,32 @@ function resolveRealHomeDir(io) {
   return (0, import_os2.homedir)();
 }
 __name(resolveRealHomeDir, "resolveRealHomeDir");
+async function readOwnerCodexSettings(jobId, io, codexHome) {
+  const read = io.sessionConfigFs?.readFile?.bind(io.sessionConfigFs);
+  if (!read) return {};
+  try {
+    return readCodexUserSettings(await read((0, import_path4.join)(codexHome, "config.toml")));
+  } catch (error) {
+    io.logger?.warn(
+      `[fleet-node] job ${jobId}: could not read the Codex config to keep its sandbox and model defaults; the run uses Codex's own defaults (still under --ignore-user-config): ${describeContainmentError(error)}`
+    );
+    return {};
+  }
+}
+__name(readOwnerCodexSettings, "readOwnerCodexSettings");
+function effectiveCodexHome(io, envOverlay, envPassthrough, envGrants) {
+  const isCodexHome = /* @__PURE__ */ __name((name) => name.toUpperCase() === "CODEX_HOME", "isCodexHome");
+  const childEnv = buildNodeCheckEnv(
+    envPassthrough?.filter(isCodexHome) ?? null,
+    io.parentEnv,
+    envGrants?.filter(isCodexHome) ?? null,
+    envOverlay
+  );
+  const key = Object.keys(childEnv).find(isCodexHome);
+  const value = key === void 0 ? void 0 : childEnv[key];
+  return typeof value === "string" && value.trim() ? value.trim() : (0, import_path4.join)(resolveRealHomeDir(io), ".codex");
+}
+__name(effectiveCodexHome, "effectiveCodexHome");
 function describeContainmentError(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -13544,6 +14226,22 @@ function resumeNeverOpened(model) {
   return RESUME_NEVER_OPENED_SIGNATURES.some((signature) => signature.test(said));
 }
 __name(resumeNeverOpened, "resumeNeverOpened");
+function recognizeModelUsageLimit(model, io = {}) {
+  if (model.status === "succeeded" || model.status === "timeout") return null;
+  const now = io.usageLimitClock?.now() ?? Date.now();
+  const timeZone = io.usageLimitClock?.timeZone ?? localTimeZone();
+  const options = { provider: model.provider, now, ...timeZone ? { timeZone } : {} };
+  return detectFleetModelUsageLimit(model.summary, options) ?? detectFleetModelUsageLimit(model.outputTail, { ...options, strict: true });
+}
+__name(recognizeModelUsageLimit, "recognizeModelUsageLimit");
+function localTimeZone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(localTimeZone, "localTimeZone");
 function describeModelFailure(model) {
   switch (model.status) {
     case "timeout":
@@ -15137,10 +15835,14 @@ var USER_SELECTABLE_WORK_KINDS2 = [
   "repo",
   "app"
 ];
-var WORK_KINDS2 = [...USER_SELECTABLE_WORK_KINDS2, "company", "campaign", "default"];
+var WORK_KINDS2 = [...USER_SELECTABLE_WORK_KINDS2, "company", "campaign", "project", "default"];
 new Set(WORK_KINDS2);
 var GOAL_KINDS2 = ["metric", "delivery"];
 new Set(GOAL_KINDS2);
+var RECORD_VISIBILITIES2 = ["private", "team", "organization"];
+new Set(RECORD_VISIBILITIES2);
+var RECORD_LIST_VIEWS2 = ["mine", "shared", "organization"];
+new Set(RECORD_LIST_VIEWS2);
 var VERSION2 = "1.0.0";
 var GTM_SKILLS2 = [
   // ── research ────────────────────────────────────────────────────────
@@ -15847,6 +16549,8 @@ Object.freeze(
   ACTION_CATEGORIES2.filter((c) => c !== "read.internal")
 );
 var DOMAIN_EVENT_CATALOG2 = [
+  // EW-P2-6 — `org:write` (and the app) create Organizations.
+  { type: "organization.created", domain: "organization", aggregateType: "organization", phase: "P2" },
   { type: "organization.updated", domain: "organization", aggregateType: "organization", phase: "P1" },
   {
     type: "organization.member.added",
@@ -15893,10 +16597,10 @@ var DOMAIN_EVENT_CATALOG2 = [
   { type: "mission.updated", domain: "missions", aggregateType: "mission", phase: "P2" },
   { type: "mission.status_changed", domain: "missions", aggregateType: "mission", phase: "P2" },
   { type: "mission.deleted", domain: "missions", aggregateType: "mission", phase: "P2" },
-  { type: "mission.goal.linked", domain: "missions", aggregateType: "mission", phase: "P2" },
-  { type: "mission.goal.unlinked", domain: "missions", aggregateType: "mission", phase: "P2" },
-  { type: "mission.work.linked", domain: "missions", aggregateType: "mission", phase: "P2" },
-  { type: "mission.work.unlinked", domain: "missions", aggregateType: "mission", phase: "P2" },
+  { type: "mission.goal.linked", domain: "missions", aggregateType: "mission", phase: "P2", child: "goal" },
+  { type: "mission.goal.unlinked", domain: "missions", aggregateType: "mission", phase: "P2", child: "goal" },
+  { type: "mission.work.linked", domain: "missions", aggregateType: "mission", phase: "P2", child: "work" },
+  { type: "mission.work.unlinked", domain: "missions", aggregateType: "mission", phase: "P2", child: "work" },
   { type: "goal.created", domain: "goals", aggregateType: "goal", phase: "P2" },
   { type: "goal.updated", domain: "goals", aggregateType: "goal", phase: "P2" },
   { type: "goal.status_changed", domain: "goals", aggregateType: "goal", phase: "P2" },
@@ -16443,6 +17147,7 @@ var LocalWorkspacePlugin = class _LocalWorkspacePlugin {
     );
     const dirty = status.stdout.trim().length > 0;
     if (dirty) {
+      const commitMessage = rewriteCommitMessage(opts, status.stdout);
       const identity = opts.identity;
       await this.gitOrThrow(
         [
@@ -16454,7 +17159,7 @@ var LocalWorkspacePlugin = class _LocalWorkspacePlugin {
           ...opts.hardenRepoHooks ? ["--no-verify"] : [],
           ...identity ? [`--author=${identity.authorName} <${identity.authorEmail}>`] : [],
           "-m",
-          opts.commitMessage
+          commitMessage
         ],
         dir,
         opts.auth,
@@ -17697,6 +18402,31 @@ function isSafeCloneArgument(url) {
   return !parsed.hostname.startsWith("-");
 }
 __name(isSafeCloneArgument, "isSafeCloneArgument");
+function parsePorcelainPaths(stdout) {
+  const paths = [];
+  for (const line of stdout.split(/\r?\n/)) {
+    if (line.length < 4) continue;
+    let path2 = line.slice(3);
+    const arrow = path2.lastIndexOf(" -> ");
+    if (arrow !== -1) path2 = path2.slice(arrow + 4);
+    if (path2.startsWith('"') && path2.endsWith('"') && path2.length >= 2) {
+      path2 = path2.slice(1, -1).replace(/\\(.)/g, "$1");
+    }
+    if (path2) paths.push(path2);
+  }
+  return paths;
+}
+__name(parsePorcelainPaths, "parsePorcelainPaths");
+function rewriteCommitMessage(opts, porcelain) {
+  if (typeof opts.commitMessageFor !== "function") return opts.commitMessage;
+  try {
+    const next = opts.commitMessageFor(parsePorcelainPaths(porcelain), opts.commitMessage);
+    return typeof next === "string" && next.trim() && !/[\0\r]/.test(next) ? next : opts.commitMessage;
+  } catch {
+    return opts.commitMessage;
+  }
+}
+__name(rewriteCommitMessage, "rewriteCommitMessage");
 
 // src/core/workspaces/push-credential.ts
 var PUSH_CREDENTIAL_REVOKE_TIMEOUT_MS = 5e3;
@@ -18615,6 +19345,11 @@ var FleetTaskWorkspaceProvisioner = class {
           // pool config. The credentialed push already does this; the flag
           // extends it to the commit.
           hardenRepoHooks: true,
+          // Fleet commit messages: once the change is staged, a
+          // docs-only change commits as `docs`, a tests-only one as
+          // `test`, whatever the Task title implied. Only the type token
+          // of the subject changes; the body and trailers are untouched.
+          commitMessageFor: /* @__PURE__ */ __name((changedPaths, message) => retypeFleetCommitMessage(message, changedPaths), "commitMessageFor"),
           ...signal ? { signal } : {},
           ...opts.publishFence ? { publishFence: opts.publishFence } : {},
           ...authorization.identity ? { identity: authorization.identity } : {},
@@ -19451,10 +20186,14 @@ var USER_SELECTABLE_WORK_KINDS3 = [
   "repo",
   "app"
 ];
-var WORK_KINDS3 = [...USER_SELECTABLE_WORK_KINDS3, "company", "campaign", "default"];
+var WORK_KINDS3 = [...USER_SELECTABLE_WORK_KINDS3, "company", "campaign", "project", "default"];
 new Set(WORK_KINDS3);
 var GOAL_KINDS3 = ["metric", "delivery"];
 new Set(GOAL_KINDS3);
+var RECORD_VISIBILITIES3 = ["private", "team", "organization"];
+new Set(RECORD_VISIBILITIES3);
+var RECORD_LIST_VIEWS3 = ["mine", "shared", "organization"];
+new Set(RECORD_LIST_VIEWS3);
 var VERSION3 = "1.0.0";
 var GTM_SKILLS3 = [
   // ── research ────────────────────────────────────────────────────────
@@ -20161,6 +20900,8 @@ Object.freeze(
   ACTION_CATEGORIES3.filter((c) => c !== "read.internal")
 );
 var DOMAIN_EVENT_CATALOG3 = [
+  // EW-P2-6 — `org:write` (and the app) create Organizations.
+  { type: "organization.created", domain: "organization", aggregateType: "organization", phase: "P2" },
   { type: "organization.updated", domain: "organization", aggregateType: "organization", phase: "P1" },
   {
     type: "organization.member.added",
@@ -20207,10 +20948,10 @@ var DOMAIN_EVENT_CATALOG3 = [
   { type: "mission.updated", domain: "missions", aggregateType: "mission", phase: "P2" },
   { type: "mission.status_changed", domain: "missions", aggregateType: "mission", phase: "P2" },
   { type: "mission.deleted", domain: "missions", aggregateType: "mission", phase: "P2" },
-  { type: "mission.goal.linked", domain: "missions", aggregateType: "mission", phase: "P2" },
-  { type: "mission.goal.unlinked", domain: "missions", aggregateType: "mission", phase: "P2" },
-  { type: "mission.work.linked", domain: "missions", aggregateType: "mission", phase: "P2" },
-  { type: "mission.work.unlinked", domain: "missions", aggregateType: "mission", phase: "P2" },
+  { type: "mission.goal.linked", domain: "missions", aggregateType: "mission", phase: "P2", child: "goal" },
+  { type: "mission.goal.unlinked", domain: "missions", aggregateType: "mission", phase: "P2", child: "goal" },
+  { type: "mission.work.linked", domain: "missions", aggregateType: "mission", phase: "P2", child: "work" },
+  { type: "mission.work.unlinked", domain: "missions", aggregateType: "mission", phase: "P2", child: "work" },
   { type: "goal.created", domain: "goals", aggregateType: "goal", phase: "P2" },
   { type: "goal.updated", domain: "goals", aggregateType: "goal", phase: "P2" },
   { type: "goal.status_changed", domain: "goals", aggregateType: "goal", phase: "P2" },
@@ -21426,6 +22167,7 @@ function createNodeRuntime(config, io, options = {}) {
   let attendedWake = null;
   const holdableLanes = [];
   let limitTarget = null;
+  let throttleTarget = null;
   const lifecycle = new NodeLifecycleTracker({
     daemonVersion: io.version,
     logger: io.logger,
@@ -21449,6 +22191,7 @@ function createNodeRuntime(config, io, options = {}) {
     onAccepted: /* @__PURE__ */ __name((response) => {
       attendedWake?.(response.pendingComputerSessions);
       lifecycle.applyHeartbeat(response);
+      throttleTarget?.(response.node?.modelThrottles);
     }, "onAccepted")
   };
   const runtime = { client, loop: new HeartbeatLoop(loopOptions), lifecycle, cliCompat };
@@ -21490,7 +22233,11 @@ function createNodeRuntime(config, io, options = {}) {
       // attended lane alone — never parked in (or holding a slot of) the
       // work lane. Sent only under `--attend`, so a work-only node's lease
       // body is exactly what it always was.
-      ...options.attendEnabled ? { excludeKinds: ["computer-session"] } : {}
+      ...options.attendEnabled ? { excludeKinds: ["computer-session"] } : {},
+      // Fleet usage limits: the CLIs an agent-task can run with here, so a
+      // node whose only CLI is out of quota stops leasing agent-task work
+      // until the reset (other kinds keep leasing).
+      modelProviders: /* @__PURE__ */ __name(() => Object.entries(options.modelCli ?? io.environment.modelCli ?? {}).filter(([, path2]) => typeof path2 === "string" && path2.length > 0).map(([provider]) => provider), "modelProviders")
     });
     holdableLanes.push(worker);
     worker.onUpgradeRequired((hold) => lifecycle.applyLeaseRefusal(hold.minNodeVersion));
@@ -21502,6 +22249,9 @@ function createNodeRuntime(config, io, options = {}) {
       }
     }, "limitTarget");
     telemetry.limits = () => worker.resourceLimits;
+    throttleTarget = /* @__PURE__ */ __name((throttles) => {
+      if (Array.isArray(throttles)) worker.syncModelThrottles(throttles);
+    }, "throttleTarget");
     telemetry.workerHealth = () => describeWorkerHealth(worker.getState());
     const housekeeping = new NodeHousekeepingReporter({
       minFreeDiskBytes: io.diskProbe ? effectiveMinFreeDiskBytes(limits) : null,
@@ -23151,10 +23901,12 @@ async function runStart(deps, options) {
   }
   const { loop, worker } = runtime;
   const attendedWorker = runtime.attended?.worker ?? null;
+  let lastLoggedBeat = null;
   loop.onChange((state) => {
-    if (state.state === "connected") {
-      deps.io.logger.info(`Heartbeat accepted \u2014 node ${config.nodeId} is online`);
-    }
+    if (state.state !== "connected") return;
+    if (lastLoggedBeat && lastLoggedBeat.node === state.node && lastLoggedBeat.at === state.lastHeartbeatAt) return;
+    lastLoggedBeat = { node: state.node, at: state.lastHeartbeatAt };
+    deps.io.logger.info(`Heartbeat accepted \u2014 node ${config.nodeId} is online`);
   });
   deps.out(`Starting node ${config.nodeId} \u2192 ${config.apiUrl} (every ${config.heartbeatIntervalMs / 1e3}s)`);
   let requestShutdown = /* @__PURE__ */ __name(() => void 0, "requestShutdown");
@@ -23170,14 +23922,47 @@ async function runStart(deps, options) {
     });
   }
   await loop.start();
-  if (worker) {
-    await worker.start();
-  }
-  if (attendedWorker) {
-    await attendedWorker.start();
-    deps.out(
-      runtime.attended?.captureBackend ? "Live view enabled \u2014 the owner can watch this machine from the dashboard (screen and terminal)" : "Live view enabled \u2014 terminal only: no browser was found here to show a screen"
-    );
+  let shuttingDown = false;
+  const startLanes = /* @__PURE__ */ __name(async () => {
+    if (worker) {
+      await worker.start();
+    }
+    if (attendedWorker) {
+      await attendedWorker.start();
+      deps.out(
+        runtime.attended?.captureBackend ? "Live view enabled \u2014 the owner can watch this machine from the dashboard (screen and terminal)" : "Live view enabled \u2014 terminal only: no browser was found here to show a screen"
+      );
+    }
+  }, "startLanes");
+  let lanesStarted = Promise.resolve();
+  let laneStartFailed = false;
+  let laneStartFailure = void 0;
+  if (worker || attendedWorker) {
+    if (loop.getState().state === "connected") {
+      await startLanes();
+    } else {
+      deps.out(
+        "Waiting for the platform to accept a heartbeat before leasing work (its answer carries this node\u2019s limits and version verdict)"
+      );
+      lanesStarted = startLanesAfterAcceptedHeartbeat(
+        loop,
+        async () => {
+          deps.io.logger.info("Heartbeat accepted \u2014 starting the worker lanes");
+          await startLanes();
+        },
+        () => !shuttingDown
+      ).then((outcome) => {
+        if (!outcome.failed) return;
+        laneStartFailed = true;
+        laneStartFailure = outcome.error;
+        deps.io.logger.error(
+          `Worker lanes failed to start after the first accepted heartbeat: ${describeError4(
+            outcome.error
+          )} \u2014 shutting down`
+        );
+        requestShutdown();
+      });
+    }
   }
   const reaper = worker && runtime.workspaceRoot ? startWorkspaceReaperTimer({
     rootPath: runtime.workspaceRoot,
@@ -23215,8 +24000,10 @@ async function runStart(deps, options) {
   }
   await (deps.waitForShutdown?.() ?? (deps.signals ? signalled : Promise.resolve()));
   reaper?.stop();
+  shuttingDown = true;
   loop.stop();
   await loop.settled();
+  await lanesStarted;
   if (attendedWorker) {
     for (const jobId of attendedWorker.getState().activeJobIds) {
       attendedWorker.cancelJob(jobId, "This machine is shutting down");
@@ -23229,8 +24016,29 @@ async function runStart(deps, options) {
     deps.out(`Worker host stopped (completed ${state.completed}, failed ${state.failed}).`);
   }
   deps.out("Stopped.");
+  if (laneStartFailed) {
+    throw new CliError(
+      `Worker lanes failed to start after the first accepted heartbeat: ${describeError4(laneStartFailure)}`,
+      EXIT_FAILURE
+    );
+  }
 }
 __name(runStart, "runStart");
+async function startLanesAfterAcceptedHeartbeat(loop, startLanes, shouldWait) {
+  const accepted = await untilHeartbeatAccepted(loop, shouldWait);
+  if (!accepted || !shouldWait()) return { started: false, failed: false };
+  try {
+    await startLanes();
+    return { started: true, failed: false };
+  } catch (error) {
+    return { started: false, failed: true, error };
+  }
+}
+__name(startLanesAfterAcceptedHeartbeat, "startLanesAfterAcceptedHeartbeat");
+function describeError4(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+__name(describeError4, "describeError");
 function parseConcurrency(raw) {
   if (raw === void 0) return void 0;
   const parsed = Number.parseInt(raw, 10);
@@ -23897,7 +24705,7 @@ function createLogger(options = {}) {
 __name(createLogger, "createLogger");
 
 // src/version.ts
-var NODE_APP_VERSION = "0.2.3";
+var NODE_APP_VERSION = "0.2.5";
 
 // src/cli.ts
 function buildDeps() {