@edgehero/pi-dispatch-admin 1.2.0 → 1.4.0

package/dist/index.mjs

@@ -7611,7 +7611,7 @@ function isForgeKind(kind) {
 function forgeSpec(kind) {
   return isForgeKind(kind) ? FORGES[kind] : void 0;
 }
-var FORGES, FORGE_KINDS, RUN_KINDS, MINTED_TOKEN_VARS;
+var FORGES, FORGE_KINDS, RUN_KINDS, MINTED_TOKEN_VARS, FORGE_HOST_VARS;
 var init_forges = __esm({
   "../worker/src/forges.mjs"() {
     FORGES = {
@@ -7677,6 +7677,13 @@ var init_forges = __esm({
     FORGE_KINDS = Object.freeze(Object.keys(FORGES));
     RUN_KINDS = Object.freeze(["local", ...FORGE_KINDS]);
     MINTED_TOKEN_VARS = new Set(FORGE_KINDS.flatMap((kind) => FORGES[kind].tokenVars));
+    FORGE_HOST_VARS = new Set(FORGE_KINDS.map((kind) => FORGES[kind].hostVar).filter((name) => typeof name === "string"));
+  }
+});
+
+// ../worker/src/secret-profiles.mjs
+var init_secret_profiles = __esm({
+  "../worker/src/secret-profiles.mjs"() {
   }
 });
 
@@ -7701,13 +7708,16 @@ function defaultGraphDir(env = process.env) {
 function defaultSettingsFile() {
   return `${process.env.TMPDIR ?? process.env.TEMP ?? "/tmp"}/pi-dispatch/settings.json`.replace(/\\/g, "/");
 }
-var CHAIN_DEPTH_MAX_DEFAULT, CHAIN_MAX_PER_JOB_DEFAULT;
+var CHAIN_DEPTH_MAX_DEFAULT, CHAIN_MAX_PER_JOB_DEFAULT, WORKER_ONLY_SECRET_VARS, EGRESS_ENV_VARS;
 var init_config2 = __esm({
   "../worker/src/config.mjs"() {
     init_egress();
     init_forges();
+    init_secret_profiles();
     CHAIN_DEPTH_MAX_DEFAULT = 1;
     CHAIN_MAX_PER_JOB_DEFAULT = 2;
+    WORKER_ONLY_SECRET_VARS = /* @__PURE__ */ new Set(["GITHUB_APP_PRIVATE_KEY"]);
+    EGRESS_ENV_VARS = /* @__PURE__ */ new Set(["HTTPS_PROXY", "HTTP_PROXY", "NO_PROXY", "NODE_USE_ENV_PROXY"]);
   }
 });
 
@@ -7752,6 +7762,21 @@ function validateOverlay(candidate, log) {
         if (!isIntInRange(value, 1, 10)) return { invalid: "concurrency must be an integer 1-10" };
         overlay[key] = value;
         break;
+      case "secretProfiles": {
+        if (value === null || typeof value !== "object" || Array.isArray(value)) {
+          return { invalid: "secretProfiles must be an object mapping profile names to resolver paths" };
+        }
+        for (const name of Object.keys(value)) {
+          if (!/^[A-Za-z0-9._-]+$/.test(name)) {
+            return { invalid: "secretProfiles names may use letters, digits, dot, dash and underscore only" };
+          }
+          if (typeof value[name] !== "string" || value[name].trim() === "") {
+            return { invalid: `secretProfiles.${name} must be a non-empty absolute path` };
+          }
+        }
+        overlay[key] = { ...value };
+        break;
+      }
       case "softHoldPct":
         if (!isIntInRange(value, 1, 99)) return { invalid: "softHoldPct must be an integer 1-99" };
         overlay[key] = value;
@@ -7861,10 +7886,399 @@ var init_budget = __esm({
   }
 });
 
-// ../worker/src/triggers.mjs
+// ../worker/src/pause-windows.mjs
 function isNonEmptyString2(value) {
   return typeof value === "string" && value.trim() !== "";
 }
+function parseHHMM(value, label, at, path) {
+  const m = isNonEmptyString2(value) ? /^([0-9]{1,2}):([0-9]{2})$/.exec(value.trim()) : null;
+  if (!m) throw configError(`${at}: ${label} must be "HH:MM": ${JSON.stringify(value)} (${path})`);
+  const h = Number(m[1]);
+  const min = Number(m[2]);
+  if (h > 23 || min > 59) throw configError(`${at}: ${label} out of range 00:00-23:59: ${JSON.stringify(value)} (${path})`);
+  return h * 60 + min;
+}
+function assertDate(value, label, at, path) {
+  const m = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(String(value).trim());
+  const mo = m && Number(m[2]);
+  const d = m && Number(m[3]);
+  if (!m || mo < 1 || mo > 12 || d < 1 || d > 31) {
+    throw configError(`${at}: ${label} must be "YYYY-MM-DD": ${JSON.stringify(value)} (${path})`);
+  }
+}
+function validateTz(tz, at, path) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: tz });
+    return tz;
+  } catch {
+    throw configError(`${at}: tz is not a valid IANA timezone: ${JSON.stringify(tz)} (${path})`);
+  }
+}
+function parsePauseWindows(text, path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    throw configError(`pause-windows file is not valid JSON: ${path} (${error.message})`);
+  }
+  const windows = parsed?.windows;
+  if (!Array.isArray(windows)) {
+    throw configError(`pause-windows file must have a "windows" array: ${path}`);
+  }
+  return windows.map((w, index) => normalizeWindow(w, index, path));
+}
+function normalizeWindow(w, index, path) {
+  const at = `pause window at index ${index}`;
+  if (w === null || typeof w !== "object") throw configError(`${at}: must be an object: ${path}`);
+  if (!isNonEmptyString2(w.scope)) throw configError(`${at}: scope must be a non-empty string: ${path}`);
+  const fromMin = parseHHMM(w.from, "from", at, path);
+  const toMin = parseHHMM(w.to, "to", at, path);
+  if (fromMin === toMin) {
+    throw configError(`${at}: from and to must differ (a 24h pause is not expressible; remove the trigger): ${path}`);
+  }
+  const tz = w.tz === void 0 ? "UTC" : validateTz(w.tz, at, path);
+  let days = null;
+  if (w.days !== void 0) {
+    if (!Array.isArray(w.days) || w.days.length === 0) {
+      throw configError(`${at}: days must be a non-empty array of weekday names (mon..sun): ${path}`);
+    }
+    days = w.days.map((d) => {
+      const key = String(d).trim().toLowerCase().slice(0, 3);
+      if (!DAY_SET.has(key)) throw configError(`${at}: unknown weekday ${JSON.stringify(d)} (use mon..sun): ${path}`);
+      return key;
+    });
+  }
+  let dateFrom = null;
+  let dateTo = null;
+  if (w.dateFrom !== void 0) {
+    assertDate(w.dateFrom, "dateFrom", at, path);
+    dateFrom = String(w.dateFrom).trim();
+  }
+  if (w.dateTo !== void 0) {
+    assertDate(w.dateTo, "dateTo", at, path);
+    dateTo = String(w.dateTo).trim();
+  }
+  if (dateFrom && dateTo && dateFrom > dateTo) throw configError(`${at}: dateFrom must be <= dateTo: ${path}`);
+  const norm = { scope: w.scope.trim(), from: w.from.trim(), to: w.to.trim(), fromMin, toMin, tz };
+  if (days) norm.days = days;
+  if (dateFrom) norm.dateFrom = dateFrom;
+  if (dateTo) norm.dateTo = dateTo;
+  return norm;
+}
+function zonedParts(tz, ms) {
+  const fmt2 = new Intl.DateTimeFormat("en-US", {
+    timeZone: tz,
+    hour12: false,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    weekday: "short"
+  });
+  const p = {};
+  for (const part of fmt2.formatToParts(new Date(ms))) p[part.type] = part.value;
+  let hh = Number(p.hour);
+  if (hh === 24) hh = 0;
+  return { y: Number(p.year), mo: Number(p.month), d: Number(p.day), hh, mi: Number(p.minute), dow: WEEKDAY_INDEX[p.weekday] };
+}
+function wallToMs(tz, y, mo, d, hh, mi) {
+  const guess = Date.UTC(y, mo - 1, d, hh, mi);
+  const shown = zonedParts(tz, guess);
+  const shownAsUtc = Date.UTC(shown.y, shown.mo - 1, shown.d, shown.hh, shown.mi);
+  return guess - (shownAsUtc - guess);
+}
+function shiftDay(tz, parts, delta) {
+  const noon = wallToMs(tz, parts.y, parts.mo, parts.d, 12, 0);
+  return zonedParts(tz, noon + delta * 864e5);
+}
+function ymd(parts) {
+  return `${String(parts.y).padStart(4, "0")}-${String(parts.mo).padStart(2, "0")}-${String(parts.d).padStart(2, "0")}`;
+}
+function qualifies(w, parts) {
+  if (w.days && !w.days.includes(DAYS[parts.dow])) return false;
+  const date = ymd(parts);
+  if (w.dateFrom && date < w.dateFrom) return false;
+  if (w.dateTo && date > w.dateTo) return false;
+  return true;
+}
+function windowEndAt(w, nowMs) {
+  const p = zonedParts(w.tz, nowMs);
+  const nowMin = p.hh * 60 + p.mi;
+  const endAt = (dateParts) => wallToMs(w.tz, dateParts.y, dateParts.mo, dateParts.d, Math.floor(w.toMin / 60), w.toMin % 60);
+  if (w.fromMin < w.toMin) {
+    if (nowMin >= w.fromMin && nowMin < w.toMin && qualifies(w, p)) return endAt(p);
+    return null;
+  }
+  if (nowMin >= w.fromMin && qualifies(w, p)) return endAt(shiftDay(w.tz, p, 1));
+  if (nowMin < w.toMin && qualifies(w, shiftDay(w.tz, p, -1))) return endAt(p);
+  return null;
+}
+var DAYS, DAY_SET, WEEKDAY_INDEX;
+var init_pause_windows = __esm({
+  "../worker/src/pause-windows.mjs"() {
+    init_config2();
+    DAYS = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+    DAY_SET = new Set(DAYS);
+    WEEKDAY_INDEX = { Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6 };
+  }
+});
+
+// ../worker/src/subscriptions.mjs
+function isNonEmptyString3(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function normalizeGlobs(value, label, at, path) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw configError(`${at}: ${label} must be a non-empty array of model globs: ${path}`);
+  }
+  return value.map((glob) => {
+    if (typeof glob !== "string" || !MODEL_GLOB_RE.test(glob.trim())) {
+      throw configError(`${at}: ${label} glob ${JSON.stringify(glob)} must match ${MODEL_GLOB_RE} (model-id charset plus "*", max 64 chars): ${path}`);
+    }
+    return glob.trim();
+  });
+}
+function normalizeBool(value, label, at, path, fallback) {
+  if (value === void 0) return fallback;
+  if (typeof value !== "boolean") throw configError(`${at}: ${label} must be a boolean: ${path}`);
+  return value;
+}
+function parseSubscriptions(text, path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    throw configError(`subscriptions file is not valid JSON: ${path} (${error.message})`);
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw configError(`subscriptions file must be a JSON object: ${path}`);
+  }
+  const version = parsed.version;
+  if (!Number.isInteger(version) || version < 1) {
+    throw configError(`subscriptions file must declare an integer "version" >= 1 (got ${JSON.stringify(version)}): ${path}`);
+  }
+  if (version > SUBSCRIPTIONS_VERSION) {
+    throw configError(`subscriptions file written by a newer pi-dispatch (version ${version}; this build understands ${SUBSCRIPTIONS_VERSION}): ${path}`);
+  }
+  const entries = parsed.subscriptions;
+  if (!Array.isArray(entries)) {
+    throw configError(`subscriptions file must have a "subscriptions" array: ${path}`);
+  }
+  const seenIds = /* @__PURE__ */ new Map();
+  return { version, subscriptions: entries.map((entry, index) => normalizeSubscription(entry, index, path, seenIds)) };
+}
+function normalizeSubscription(entry, index, path, seenIds) {
+  const at = `subscription at index ${index}`;
+  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+    throw configError(`${at}: must be an object: ${path}`);
+  }
+  if (!isNonEmptyString3(entry.id)) throw configError(`${at}: id must be a non-empty string: ${path}`);
+  const id = entry.id.trim();
+  if (seenIds.has(id)) {
+    throw configError(`${at}: id ${JSON.stringify(id)} is already used by the subscription at index ${seenIds.get(id)}: ${path}`);
+  }
+  seenIds.set(id, index);
+  if (!isNonEmptyString3(entry.vendor)) throw configError(`${at}: vendor must be a non-empty string: ${path}`);
+  if (!isNonEmptyString3(entry.provider)) throw configError(`${at}: provider must be a non-empty string (the pi-ai provider id this plan covers): ${path}`);
+  const models = entry.models === void 0 ? ["*"] : normalizeGlobs(entry.models, "models", at, path);
+  const price = entry.price;
+  if (price === null || typeof price !== "object" || Array.isArray(price)) {
+    throw configError(`${at}: price must be an object { amount, currency, per }: ${path}`);
+  }
+  if (typeof price.amount !== "number" || !Number.isFinite(price.amount) || price.amount <= 0) {
+    throw configError(`${at}: price.amount must be a number > 0: ${path}`);
+  }
+  if (typeof price.currency !== "string" || !/^[A-Z]{3}$/.test(price.currency)) {
+    throw configError(`${at}: price.currency must be a 3-letter uppercase code (e.g. "USD"): ${path}`);
+  }
+  if (price.per !== "month") {
+    throw configError(`${at}: price.per must be "month" (got ${JSON.stringify(price.per)}): ${path}`);
+  }
+  const sharedWithOtherProducts = normalizeBool(entry.sharedWithOtherProducts, "sharedWithOtherProducts", at, path, false);
+  const hypothetical = normalizeBool(entry.hypothetical, "hypothetical", at, path, false);
+  let counterfactualModel = null;
+  if (entry.counterfactualModel !== void 0 && entry.counterfactualModel !== null) {
+    const cm = entry.counterfactualModel;
+    if (typeof cm !== "object" || Array.isArray(cm) || !isNonEmptyString3(cm.provider) || !isNonEmptyString3(cm.id)) {
+      throw configError(`${at}: counterfactualModel must be { provider, id } with non-empty strings (a PRICED pi-ai model to re-price covered runs at API rates): ${path}`);
+    }
+    counterfactualModel = { provider: cm.provider.trim(), id: cm.id.trim() };
+  }
+  let windows = [];
+  if (entry.windows !== void 0) {
+    if (!Array.isArray(entry.windows)) throw configError(`${at}: windows must be an array: ${path}`);
+    windows = entry.windows.map((w, windowIndex) => normalizeWindow2(w, windowIndex, index, path));
+  }
+  return {
+    id,
+    vendor: entry.vendor.trim(),
+    provider: entry.provider.trim(),
+    models,
+    price: { amount: price.amount, currency: price.currency, per: "month" },
+    sharedWithOtherProducts,
+    hypothetical,
+    counterfactualModel,
+    windows
+  };
+}
+function normalizeWindow2(w, windowIndex, subIndex, path) {
+  const at = `window at index ${windowIndex} of subscription at index ${subIndex}`;
+  if (w === null || typeof w !== "object" || Array.isArray(w)) {
+    throw configError(`${at}: must be an object: ${path}`);
+  }
+  if (!WINDOW_PERS.has(w.per)) {
+    throw configError(`${at}: per must be one of 5h|7d|30d|month (got ${JSON.stringify(w.per)}): ${path}`);
+  }
+  const rolling = normalizeBool(w.rolling, "rolling", at, path, false);
+  let unit = null;
+  if (w.unit !== void 0 && w.unit !== null) {
+    if (!WINDOW_UNITS.has(w.unit)) {
+      throw configError(`${at}: unit must be one of tokens|requests|prompts|credits, or null (vendor undisclosed): ${path}`);
+    }
+    unit = w.unit;
+  }
+  let limit = null;
+  if (w.limit !== void 0 && w.limit !== null) {
+    if (typeof w.limit === "number") {
+      if (!Number.isFinite(w.limit) || w.limit <= 0) throw configError(`${at}: limit must be a number > 0, [min, max], or null (vendor undisclosed): ${path}`);
+      limit = w.limit;
+    } else if (Array.isArray(w.limit)) {
+      const [min, max] = w.limit;
+      if (w.limit.length !== 2 || typeof min !== "number" || typeof max !== "number" || !Number.isFinite(min) || !Number.isFinite(max) || min <= 0 || max <= 0 || min >= max) {
+        throw configError(`${at}: limit range must be [min, max] with both > 0 and min < max: ${path}`);
+      }
+      limit = [min, max];
+    } else {
+      throw configError(`${at}: limit must be a number > 0, [min, max], or null (vendor undisclosed): ${path}`);
+    }
+  }
+  const scope = w.scope === void 0 || w.scope === null ? null : normalizeGlobs(w.scope, "scope", at, path);
+  return { per: w.per, rolling, unit, limit, scope };
+}
+var SUBSCRIPTIONS_VERSION, WINDOW_PERS, WINDOW_UNITS, MODEL_GLOB_RE;
+var init_subscriptions = __esm({
+  "../worker/src/subscriptions.mjs"() {
+    init_config2();
+    SUBSCRIPTIONS_VERSION = 1;
+    WINDOW_PERS = /* @__PURE__ */ new Set(["5h", "7d", "30d", "month"]);
+    WINDOW_UNITS = /* @__PURE__ */ new Set(["tokens", "requests", "prompts", "credits"]);
+    MODEL_GLOB_RE = /^[A-Za-z0-9*._:/-]{1,64}$/;
+  }
+});
+
+// ../worker/src/connection.mjs
+import { Redis } from "ioredis";
+function parseConnection(url, { failFast = false } = {}) {
+  const u = new URL(url);
+  return {
+    host: u.hostname || "127.0.0.1",
+    port: Number(u.port || 6379),
+    ...u.password ? { password: u.password } : {},
+    ...u.username ? { username: u.username } : {},
+    ...u.pathname && u.pathname !== "/" ? { db: Number(u.pathname.slice(1)) } : {},
+    maxRetriesPerRequest: null,
+    // required for BullMQ blocking connections
+    ...failFast ? {
+      connectTimeout: 2e3,
+      enableOfflineQueue: false,
+      // don't buffer commands while disconnected -- error now
+      retryStrategy: (attempts) => attempts > 2 ? null : 200
+      // give up after ~2 tries
+    } : {}
+  };
+}
+function makeRedisClient(url) {
+  return new Redis(url, { maxRetriesPerRequest: null });
+}
+var init_connection = __esm({
+  "../worker/src/connection.mjs"() {
+  }
+});
+
+// ../worker/src/job-id.mjs
+import { createHash } from "node:crypto";
+function localJobId({ folder, flow, task, minute }) {
+  const digest = createHash("sha256").update([folder, flow ?? "", task ?? "", minute].join("\0")).digest("hex");
+  return `local-${digest.slice(0, 16)}`;
+}
+var init_job_id = __esm({
+  "../worker/src/job-id.mjs"() {
+    init_config2();
+    init_forges();
+  }
+});
+
+// ../worker/src/flow-gate.mjs
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+async function readFlowGate({ folder, flow, sha, git = defaultGit }) {
+  if (typeof sha !== "string" || sha.trim() === "") return { gate: "deny" };
+  if (typeof flow !== "string" || !SKILL_NAME_RE.test(flow)) return { gate: "deny" };
+  const path = `.pi/skills/${flow}/SKILL.md`;
+  try {
+    const lsTreeZ = await git(folder, ["ls-tree", "-z", sha, path]);
+    const record = lsTreeZ.split("\0").find((r) => r);
+    if (!record) return { gate: "no-skill" };
+    const tab = record.indexOf("	");
+    if (tab === -1) return { gate: "deny" };
+    const [mode, type, oid] = record.slice(0, tab).split(/\s+/);
+    if (mode !== "100644" || type !== "blob") return { gate: "deny" };
+    const content = await git(folder, ["cat-file", "blob", oid], { raw: true });
+    return { gate: aiTriggerAllows(content) ? "allow" : "deny" };
+  } catch {
+    return { gate: "deny" };
+  }
+}
+function aiTriggerAllows(buf) {
+  const text = buf.toString("utf8").replace(/^\uFEFF/, "").replace(/\r\n/g, "\n");
+  const block = /^---\n([\s\S]*?)\n---(?:\n|$)/.exec(text);
+  if (!block) return false;
+  return /^ai-trigger:\s*("?)allow\1\s*$/m.test(block[1]);
+}
+async function defaultGit(gitDir, args, { raw = false } = {}) {
+  const hardened = ["-c", "core.hooksPath=/dev/null", "-c", "core.fsmonitor=false", "--no-pager", "-C", gitDir, ...args];
+  const { stdout } = await exec("git", hardened, {
+    encoding: raw ? "buffer" : "utf8",
+    maxBuffer: 16 * 1024 * 1024
+  });
+  return stdout;
+}
+var exec, SKILL_NAME_RE;
+var init_flow_gate = __esm({
+  "../worker/src/flow-gate.mjs"() {
+    exec = promisify(execFile);
+    SKILL_NAME_RE = /^[a-z0-9](?:[a-z0-9_-]{0,62}[a-z0-9])?$/;
+  }
+});
+
+// ../worker/src/reserved-env.mjs
+var CONTAINER_ENV_NAMES;
+var init_reserved_env = __esm({
+  "../worker/src/reserved-env.mjs"() {
+    CONTAINER_ENV_NAMES = /* @__PURE__ */ new Set([
+      "PI_PROVIDER",
+      "PI_MODEL",
+      "PI_MAX_TURNS",
+      "PI_MAX_TOKENS",
+      "PI_JOB_ID",
+      "PI_GLOBAL_ALLOW_EXTENSIONS",
+      "PI_PACKAGES",
+      "PI_SESSION_FILE",
+      "PI_FLOW",
+      "PI_COMMAND",
+      "PI_OFFLINE",
+      "PLAYWRIGHT_BROWSERS_PATH",
+      "PLAYWRIGHT_MCP_BROWSER",
+      "PLAYWRIGHT_MCP_SANDBOX"
+    ]);
+  }
+});
+
+// ../worker/src/triggers.mjs
+function isNonEmptyString4(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
 function parseTriggers(text, path) {
   let parsed;
   try {
@@ -7892,7 +8306,7 @@ function normalizeTrigger(entry, index, path, state) {
     throw configError(`${at}: "run" must be an object: ${path}`);
   }
   if (!ON_TYPES.has(on.type)) {
-    throw configError(`${at}: on.type must be one of cron|label|comment|pull_request (got ${JSON.stringify(on.type)}): ${path}`);
+    throw configError(`${at}: on.type must be one of ${[...ON_TYPES].join("|")} (got ${JSON.stringify(on.type)}): ${path}`);
   }
   if (!RUN_KINDS.includes(run.kind)) {
     throw configError(`${at}: run.kind must be one of ${RUN_KINDS.join("|")} (got ${JSON.stringify(run.kind)}): ${path}`);
@@ -7906,14 +8320,18 @@ function normalizeTrigger(entry, index, path, state) {
   if (!isForgeKind(run.kind)) {
     throw configError(`${at}: a ${on.type} trigger is webhook-driven and produces a forge job; run.kind must be one of ${FORGE_KINDS.join("|")} (got ${JSON.stringify(run.kind)}): ${path}`);
   }
-  if (on.type === "label") return normalizeLabel(on, run, index, path);
-  if (on.type === "comment") return normalizeComment(on, run, index, path, state);
-  return normalizePullRequest(on, run, index, path);
+  let normalized;
+  if (on.type === "label") normalized = normalizeLabel(on, run, index, path);
+  else if (on.type === "comment") normalized = normalizeComment(on, run, index, path, state);
+  else if (on.type === "issue") normalized = normalizeIssue(on, run, index, path);
+  else normalized = normalizePullRequest(on, run, index, path);
+  if (on.disarmed !== void 0) return { on: { type: DISARMED_TYPE }, run: {} };
+  return normalized;
 }
 function normalizeCron(on, run, index, path, state) {
   const at = `trigger at index ${index}`;
   const id = on.id;
-  if (!isNonEmptyString2(id)) {
+  if (!isNonEmptyString4(id)) {
     throw configError(`${at}: cron on.id must be a non-empty string: ${path}`);
   }
   if (id.includes(":")) {
@@ -7927,7 +8345,7 @@ function normalizeCron(on, run, index, path, state) {
   }
   state.seenCronIds.add(id);
   const pattern = on.pattern;
-  if (!isNonEmptyString2(pattern)) {
+  if (!isNonEmptyString4(pattern)) {
     throw configError(`cron trigger "${id}": on.pattern must be a non-empty string: ${path}`);
   }
   const fieldCount = pattern.trim().split(/\s+/).length;
@@ -7935,13 +8353,13 @@ function normalizeCron(on, run, index, path, state) {
     throw configError(`cron trigger "${id}": on.pattern must have 5 or 6 space-separated fields, got ${fieldCount}: ${path}`);
   }
   const command = validateCommand(run, `cron trigger "${id}"`, path, { onType: "cron" });
-  if (!isNonEmptyString2(run.folder)) {
+  if (!isNonEmptyString4(run.folder)) {
     throw configError(`cron trigger "${id}": run.folder must be a non-empty string: ${path}`);
   }
-  if (command === void 0 && !isNonEmptyString2(run.flow)) {
+  if (command === void 0 && !isNonEmptyString4(run.flow)) {
     throw configError(`cron trigger "${id}": run.flow must be a non-empty string (or use run.command): ${path}`);
   }
-  if (command === void 0 && !isNonEmptyString2(run.task)) {
+  if (command === void 0 && !isNonEmptyString4(run.task)) {
     throw configError(`cron trigger "${id}": run.task must be a non-empty string: ${path}`);
   }
   if (run.github !== void 0 && typeof run.github !== "boolean") {
@@ -7953,9 +8371,14 @@ function normalizeCron(on, run, index, path, state) {
   validateInstructions(run, `cron trigger "${id}"`, path, { cron: true });
   const resume = validateResumeFlag(run, `cron trigger "${id}"`, path);
   validateReplicas(run, `cron trigger "${id}"`, path);
+  validateNumber(on, `cron trigger "${id}"`, path, { onType: "cron" });
+  validateOnce(on, run, `cron trigger "${id}"`, path, { onType: "cron" });
+  validateDisarmed(on, `cron trigger "${id}"`, path, { onType: "cron" });
+  const secrets = validateSecrets(run, `cron trigger "${id}"`, path);
+  const secretsProfile = validateSecretsProfile(run, `cron trigger "${id}"`, path);
   return {
     on: { type: "cron", id, pattern },
-    run: { kind: "local", folder: run.folder, flow: run.flow, task: run.task, provider: run.provider, model: run.model, maxTurns: run.maxTurns, github: run.github, packages, image, resume, ...command !== void 0 && { command }, ...skillsDir !== void 0 && { skillsDir } }
+    run: { kind: "local", folder: run.folder, flow: run.flow, task: run.task, provider: run.provider, model: run.model, maxTurns: run.maxTurns, github: run.github, packages, image, resume, ...command !== void 0 && { command }, ...skillsDir !== void 0 && { skillsDir }, ...secrets !== void 0 && { secrets }, ...secretsProfile !== void 0 && { secretsProfile } }
   };
 }
 function validatePackagesFlag(run, at, path) {
@@ -8020,7 +8443,7 @@ function validateCommand(run, at, path, { onType }) {
     throw configError(`${at}: exactly one of run.flow or run.command must be set -- a trigger dispatches either a flow or a registered command, and with both present the file does not say which one runs: ${path}`);
   }
   if (raw === void 0) return void 0;
-  if (!isNonEmptyString2(raw)) {
+  if (!isNonEmptyString4(raw)) {
     throw configError(`${at}: run.command must be a non-empty string -- the registered command name, optionally followed by its arguments: ${path}`);
   }
   if (raw !== raw.trim()) {
@@ -8057,6 +8480,72 @@ function validatePredicate(on, index, path, requirePositive) {
   }
   return { any: on.any, all: on.all, none: on.none };
 }
+function validateNumber(on, at, path, { capable = false, onType } = {}) {
+  const number = on.number;
+  if (number === void 0) return void 0;
+  if (!capable) {
+    if (onType === "cron") {
+      throw configError(`${at}: on.number is not available on a cron trigger -- a schedule fires on time, not on an item, so there is no delivery for a number to narrow: ${path}`);
+    }
+    throw configError(`${at}: on.number is not yet covered for ${onType} triggers here -- only the close routes read it, so on a rule they never serve it would sit in the file looking configured; narrowing labels, comments or non-close pull_request rules is a gap to close, not a limit: ${path}`);
+  }
+  if (!Number.isInteger(number) || number < 1) {
+    throw configError(`${at}: on.number must be an integer >= 1 when present -- the item number the forge itself assigns (on GitLab, the iid) (got ${JSON.stringify(number)}): ${path}`);
+  }
+  return number;
+}
+function validateOnce(on, run, at, path, { capable = false, onType } = {}) {
+  const once = on.once;
+  if (once === void 0) return void 0;
+  if (!capable) {
+    if (onType === "cron") {
+      throw configError(`${at}: on.once is not available on a cron trigger -- a one-shot that can re-arm is a schedule, and a cron job carries no matched delivery for the disarm to name; delete the entry when the work is done: ${path}`);
+    }
+    const closeWords = Object.entries(PR_CLOSE_ACTIONS).map(([k, w]) => `${k} has ${JSON.stringify(w)}`).join(", ");
+    throw configError(`${at}: on.once is not yet covered here -- the disarm writes back to the one entry a delivery matched, and only a close delivery names the single item that spends it; use on.type "issue", or a pull_request rule whose only action is the close word (${closeWords}; azure has no close trigger yet): ${path}`);
+  }
+  if (typeof once !== "boolean") {
+    throw configError(`${at}: on.once must be true or false when present -- a truthy string arming a one-shot is exactly the drift this validator exists to refuse (got ${JSON.stringify(once)}): ${path}`);
+  }
+  if (once === true && on.number === void 0) {
+    throw configError(`${at}: on.once requires on.number -- a one-shot without a named item is spent by whichever close arrives first, and two different items closing inside one dedup window would race for it; the number is also the identity the disarm re-checks before it writes: ${path}`);
+  }
+  if (once === true && run.replicas !== void 0) {
+    throw configError(`${at}: on.once and run.replicas cannot be combined -- "exactly one run" and "N sandboxes race" contradict, and with N run records the disarm no longer says which one spent the trigger: ${path}`);
+  }
+  return once;
+}
+function validateDisarmed(on, at, path, { capable = false, onType } = {}) {
+  const disarmed = on.disarmed;
+  if (disarmed === void 0) return void 0;
+  if (!capable) {
+    throw configError(`${at}: on.disarmed marks a spent one-shot, and on.once is not ${onType === "cron" ? "available on a cron trigger" : "yet covered here"}, so there is nothing this entry could have spent: ${path}`);
+  }
+  if (disarmed === null || typeof disarmed !== "object" || Array.isArray(disarmed)) {
+    throw configError(`${at}: on.disarmed must be an object with a non-empty string "at" (and optionally a non-empty string "jobId") -- the worker writes it when the one-shot fires, and a hand-written one disarms the entry deliberately (got ${JSON.stringify(disarmed)}): ${path}`);
+  }
+  for (const key of Object.keys(disarmed)) {
+    if (key !== "at" && key !== "jobId") {
+      throw configError(`${at}: on.disarmed has an unsupported key ${JSON.stringify(key)} (expected at|jobId): ${path}`);
+    }
+  }
+  if (!isNonEmptyString4(disarmed.at)) {
+    throw configError(`${at}: on.disarmed.at must be a non-empty string (the time the one-shot fired): ${path}`);
+  }
+  if (disarmed.jobId !== void 0 && !isNonEmptyString4(disarmed.jobId)) {
+    throw configError(`${at}: on.disarmed.jobId must be a non-empty string when present (the run record it joins to): ${path}`);
+  }
+  if (on.once !== true) {
+    throw configError(`${at}: on.disarmed is only meaningful beside on.once: true -- an entry that was never a one-shot has nothing to spend: ${path}`);
+  }
+  return disarmed;
+}
+function validateFlowName(run, at, path) {
+  if (run.flow === void 0) return;
+  if (!SKILL_NAME_RE.test(run.flow)) {
+    throw configError(`${at}: run.flow ${JSON.stringify(run.flow)} fails the skill-name charset (lowercase letters, digits, dash and underscore, 1-64 chars, starting and ending alphanumeric) -- a name outside it can never materialise, so this trigger could only ever fail after the budget slot was reserved: ${path}`);
+  }
+}
 function validateRepository(run, onType, at, path) {
   const needed = run.kind === "azure" && (onType === "label" || onType === "comment");
   const raw = run.repository;
@@ -8067,7 +8556,7 @@ function validateRepository(run, onType, at, path) {
   if (!needed) {
     throw configError(`${at}: run.repository is only meaningful on an azure label or comment trigger (a pull request names its own repository): ${path}`);
   }
-  if (!isNonEmptyString2(raw) || raw !== raw.trim() || raw.includes("/")) {
+  if (!isNonEmptyString4(raw) || raw !== raw.trim() || raw.includes("/")) {
     throw configError(`${at}: run.repository must be a non-empty repository NAME within the project, with no slashes and no surrounding whitespace (got ${JSON.stringify(raw)}): ${path}`);
   }
   return raw;
@@ -8086,13 +8575,67 @@ function validateReplicas(run, at, path) {
   }
   return replicas;
 }
+function validateSecrets(run, at, path) {
+  const secrets = run.secrets;
+  if (secrets === void 0) return void 0;
+  if (secrets === null || typeof secrets !== "object" || Array.isArray(secrets)) {
+    throw configError(`${at}: run.secrets must be an object mapping environment variable names to references when present (got ${JSON.stringify(secrets)}): ${path}`);
+  }
+  const names = Object.keys(secrets);
+  if (names.length === 0) {
+    throw configError(`${at}: run.secrets is empty -- an empty map is a field that does nothing, and this trigger reads as though it binds a secret: ${path}`);
+  }
+  if (names.length > SECRETS_MAX) {
+    throw configError(`${at}: run.secrets names ${names.length} variables, over the ${SECRETS_MAX} cap -- each one is resolved before the container starts, holding a concurrency slot while it runs: ${path}`);
+  }
+  for (const name of names) {
+    if (!ENV_NAME.test(name)) {
+      throw configError(`${at}: run.secrets key ${JSON.stringify(name)} is not an environment variable name (letters, digits and underscore, not starting with a digit): ${path}`);
+    }
+    if (RESERVED_ENV_NAMES.has(name)) {
+      throw configError(`${at}: run.secrets key ${JSON.stringify(name)} is a variable the worker sets itself -- the job container would receive the worker's value, not this trigger's, and the trigger would look like it worked: ${path}`);
+    }
+    const reference = secrets[name];
+    if (!isNonEmptyString4(reference)) {
+      throw configError(`${at}: run.secrets.${name} must be a non-empty string reference for your resolver to read (got ${JSON.stringify(reference)}): ${path}`);
+    }
+    if (reference !== reference.trim()) {
+      throw configError(`${at}: run.secrets.${name} must not have leading or trailing whitespace -- the file is the reviewed artifact and silently trimming it would make the file disagree with what the resolver is asked for: ${path}`);
+    }
+    if (reference.startsWith("-")) {
+      throw configError(`${at}: run.secrets.${name} must not start with "-" -- it is passed as the resolver's first argument, where a leading dash parses as a flag: ${path}`);
+    }
+  }
+  if (run.resume === true) {
+    throw configError(`${at}: run.secrets and run.resume cannot be combined -- a resumed job replays a transcript kept on host disk, and any command the agent ran that echoed a resolved value wrote it into that transcript, which is then prefilled into every later job on the same key: ${path}`);
+  }
+  return { ...secrets };
+}
+function validateSecretsProfile(run, at, path) {
+  const profile = run.secretsProfile;
+  if (profile === void 0) return void 0;
+  if (!isNonEmptyString4(profile)) {
+    throw configError(`${at}: run.secretsProfile must be a non-empty string naming one of the resolver profiles this deployment declares (got ${JSON.stringify(profile)}): ${path}`);
+  }
+  if (!ID_CHARSET.test(profile)) {
+    throw configError(`${at}: run.secretsProfile ${JSON.stringify(profile)} may use letters, digits, dot, dash and underscore only -- PI_SECRET_PROFILES is a comma-separated list of name:path pairs, so a name carrying either separator cannot be declared: ${path}`);
+  }
+  if (run.secrets === void 0) {
+    throw configError(`${at}: run.secretsProfile is set but run.secrets names nothing -- a profile that resolves no references is a field that does nothing: ${path}`);
+  }
+  return profile;
+}
 function normalizeLabel(on, run, index, path) {
   const at = `trigger at index ${index}`;
   const predicate = validatePredicate(on, index, path, true);
+  validateNumber(on, at, path, { onType: "label" });
+  validateOnce(on, run, at, path, { onType: "label" });
+  validateDisarmed(on, at, path, { onType: "label" });
   const command = validateCommand(run, at, path, { onType: "label" });
-  if (command === void 0 && !isNonEmptyString2(run.flow)) {
+  if (command === void 0 && !isNonEmptyString4(run.flow)) {
     throw configError(`${at}: label trigger run.flow must be a non-empty string (or use run.command): ${path}`);
   }
+  validateFlowName(run, at, path);
   const packages = validatePackagesFlag(run, at, path);
   const image = validateImageRef(run, at, path);
   const skillsDir = validateSkillsDir(run, at, path);
@@ -8100,20 +8643,26 @@ function normalizeLabel(on, run, index, path) {
   const resume = validateResumeFlag(run, at, path);
   const repository = validateRepository(run, "label", at, path);
   const replicas = validateReplicas(run, at, path);
+  const secrets = validateSecrets(run, at, path);
+  const secretsProfile = validateSecretsProfile(run, at, path);
   return {
     on: { type: "label", any: predicate.any, all: predicate.all, none: predicate.none },
-    run: { kind: run.kind, flow: run.flow, packages, image, resume, replicas, ...command !== void 0 && { command }, ...skillsDir !== void 0 && { skillsDir }, ...instructions !== void 0 && { instructions }, ...repository !== void 0 && { repository } }
+    run: { kind: run.kind, flow: run.flow, packages, image, resume, replicas, ...command !== void 0 && { command }, ...skillsDir !== void 0 && { skillsDir }, ...instructions !== void 0 && { instructions }, ...repository !== void 0 && { repository }, ...secrets !== void 0 && { secrets }, ...secretsProfile !== void 0 && { secretsProfile } }
   };
 }
 function normalizeComment(on, run, index, path, state) {
   const at = `trigger at index ${index}`;
-  if (!isNonEmptyString2(on.phrase)) {
+  if (!isNonEmptyString4(on.phrase)) {
     throw configError(`${at}: comment trigger on.phrase must be a non-empty string: ${path}`);
   }
+  validateNumber(on, at, path, { onType: "comment" });
+  validateOnce(on, run, at, path, { onType: "comment" });
+  validateDisarmed(on, at, path, { onType: "comment" });
   const command = validateCommand(run, at, path, { onType: "comment" });
-  if (command === void 0 && !isNonEmptyString2(run.flow)) {
+  if (command === void 0 && !isNonEmptyString4(run.flow)) {
     throw configError(`${at}: comment trigger run.flow (the default flow) must be a non-empty string (or use run.command): ${path}`);
   }
+  validateFlowName(run, at, path);
   state.commentCounts[run.kind] = (state.commentCounts[run.kind] ?? 0) + 1;
   if (state.commentCounts[run.kind] > 1) {
     throw configError(`${at}: at most one ${run.kind} comment trigger is allowed: ${path}`);
@@ -8125,9 +8674,59 @@ function normalizeComment(on, run, index, path, state) {
   const resume = validateResumeFlag(run, at, path);
   const repository = validateRepository(run, "comment", at, path);
   const replicas = validateReplicas(run, at, path);
+  const secrets = validateSecrets(run, at, path);
+  const secretsProfile = validateSecretsProfile(run, at, path);
   return {
     on: { type: "comment", phrase: on.phrase },
-    run: { kind: run.kind, flow: run.flow, packages, image, resume, replicas, ...command !== void 0 && { command }, ...skillsDir !== void 0 && { skillsDir }, ...instructions !== void 0 && { instructions }, ...repository !== void 0 && { repository } }
+    run: { kind: run.kind, flow: run.flow, packages, image, resume, replicas, ...command !== void 0 && { command }, ...skillsDir !== void 0 && { skillsDir }, ...instructions !== void 0 && { instructions }, ...repository !== void 0 && { repository }, ...secrets !== void 0 && { secrets }, ...secretsProfile !== void 0 && { secretsProfile } }
+  };
+}
+function normalizeIssue(on, run, index, path) {
+  const at = `trigger at index ${index}`;
+  if (run.kind === "azure") {
+    throw configError(`${at}: an issue trigger is not yet covered for azure -- a work item's close is a System.State transition whose terminal names vary by process template (Agile "Closed", Scrum "Done"), and the projected subset carries only System.Tags, so nothing in the delivery says the item closed; widening the payload subset is the gap to close, not a limit: ${path}`);
+  }
+  const actions = on.action;
+  if (!Array.isArray(actions) || actions.length === 0) {
+    throw configError(`${at}: issue on.action must be a non-empty array: ${path}`);
+  }
+  const allowed = ISSUE_ACTIONS[run.kind];
+  const expected = [...allowed].join("|");
+  for (const a of actions) {
+    if (!allowed.has(a)) {
+      throw configError(`${at}: issue on.action has an unsupported ${run.kind} action ${JSON.stringify(a)} (expected ${expected}): ${path}`);
+    }
+  }
+  if (on.any !== void 0 || on.all !== void 0 || on.none !== void 0) {
+    throw configError(`${at}: an issue trigger cannot carry a label predicate -- it fires on a lifecycle action, not a label diff, so any/all/none could never match; a label-predicated rule is on.type "label": ${path}`);
+  }
+  const number = validateNumber(on, at, path, { capable: true, onType: "issue" });
+  const once = validateOnce(on, run, at, path, { capable: true, onType: "issue" });
+  validateDisarmed(on, at, path, { capable: true, onType: "issue" });
+  const command = validateCommand(run, at, path, { onType: "issue" });
+  if (command === void 0 && !isNonEmptyString4(run.flow)) {
+    throw configError(`${at}: issue trigger run.flow must be a non-empty string (or use run.command): ${path}`);
+  }
+  validateFlowName(run, at, path);
+  const packages = validatePackagesFlag(run, at, path);
+  const image = validateImageRef(run, at, path);
+  const skillsDir = validateSkillsDir(run, at, path);
+  const instructions = validateInstructions(run, at, path);
+  const resume = validateResumeFlag(run, at, path);
+  validateRepository(run, "issue", at, path);
+  const replicas = validateReplicas(run, at, path);
+  const secrets = validateSecrets(run, at, path);
+  const secretsProfile = validateSecretsProfile(run, at, path);
+  return {
+    on: {
+      type: "issue",
+      action: [...actions],
+      // Absent rather than present-and-undefined, reviewState's rule below: an unnarrowed rule's
+      // normalized shape must not grow keys.
+      ...number !== void 0 && { number },
+      ...once !== void 0 && { once }
+    },
+    run: { kind: run.kind, flow: run.flow, packages, image, resume, replicas, ...command !== void 0 && { command }, ...skillsDir !== void 0 && { skillsDir }, ...instructions !== void 0 && { instructions }, ...secrets !== void 0 && { secrets }, ...secretsProfile !== void 0 && { secretsProfile } }
   };
 }
 function normalizePullRequest(on, run, index, path) {
@@ -8143,17 +8742,29 @@ function normalizePullRequest(on, run, index, path) {
       throw configError(`${at}: pull_request on.action has an unsupported ${run.kind} action ${JSON.stringify(a)} (expected ${expected}): ${path}`);
     }
   }
+  const closeWord = PR_CLOSE_ACTIONS[run.kind];
+  const isClose = closeWord !== void 0 && actions.includes(closeWord);
+  if (isClose && actions.some((a) => a !== closeWord)) {
+    throw configError(`${at}: pull_request on.action cannot mix ${JSON.stringify(closeWord)} with other actions -- a close rule is gated on the closer's write access and every other action on the author's, and one rule cannot gate on two different actors; split it into two entries: ${path}`);
+  }
   const reviewState = validateReviewState(on, actions, run, at, path);
   const labelAction = forgeSpec(run.kind)?.prLabelAction;
   const requirePositive = typeof labelAction === "string" && actions.includes(labelAction);
   if (run.kind === "azure" && (on.any !== void 0 || on.all !== void 0 || on.none !== void 0)) {
     throw configError(`${at}: an azure pull_request trigger cannot carry a label predicate -- Azure DevOps attaches tags to work items, never to pull requests, so any/all/none could never match: ${path}`);
   }
+  if (isClose && (on.any !== void 0 || on.all !== void 0 || on.none !== void 0)) {
+    throw configError(`${at}: a close pull_request rule cannot carry a label predicate -- the close route matches the action and on.number alone, so any/all/none would sit in the file looking configured and never match anything: ${path}`);
+  }
   const predicate = validatePredicate(on, index, path, requirePositive);
+  const number = validateNumber(on, at, path, { capable: isClose, onType: "pull_request" });
+  const once = validateOnce(on, run, at, path, { capable: isClose, onType: "pull_request" });
+  validateDisarmed(on, at, path, { capable: isClose, onType: "pull_request" });
   const command = validateCommand(run, at, path, { onType: "pull_request" });
-  if (command === void 0 && !isNonEmptyString2(run.flow)) {
+  if (command === void 0 && !isNonEmptyString4(run.flow)) {
     throw configError(`${at}: pull_request trigger run.flow must be a non-empty string (or use run.command): ${path}`);
   }
+  validateFlowName(run, at, path);
   const packages = validatePackagesFlag(run, at, path);
   const image = validateImageRef(run, at, path);
   const skillsDir = validateSkillsDir(run, at, path);
@@ -8161,6 +8772,8 @@ function normalizePullRequest(on, run, index, path) {
   const resume = validateResumeFlag(run, at, path);
   validateRepository(run, "pull_request", at, path);
   const replicas = validateReplicas(run, at, path);
+  const secrets = validateSecrets(run, at, path);
+  const secretsProfile = validateSecretsProfile(run, at, path);
   return {
     on: {
       type: "pull_request",
@@ -8170,9 +8783,12 @@ function normalizePullRequest(on, run, index, path) {
       ...reviewState !== void 0 && { reviewState },
       any: predicate.any,
       all: predicate.all,
-      none: predicate.none
+      none: predicate.none,
+      // Same rule for the close-narrowing pair (issue #231): only a close-only rule can carry them.
+      ...number !== void 0 && { number },
+      ...once !== void 0 && { once }
     },
-    run: { kind: run.kind, flow: run.flow, packages, image, resume, replicas, ...command !== void 0 && { command }, ...skillsDir !== void 0 && { skillsDir }, ...instructions !== void 0 && { instructions } }
+    run: { kind: run.kind, flow: run.flow, packages, image, resume, replicas, ...command !== void 0 && { command }, ...skillsDir !== void 0 && { skillsDir }, ...instructions !== void 0 && { instructions }, ...secrets !== void 0 && { secrets }, ...secretsProfile !== void 0 && { secretsProfile } }
   };
 }
 function validateReviewState(on, actions, run, at, path) {
@@ -8194,366 +8810,58 @@ function validateReviewState(on, actions, run, at, path) {
   }
   return [...on.reviewState];
 }
-var ON_TYPES, PR_ACTIONS, REVIEW_STATES, REVIEW_ACTION, ID_CHARSET, REPLICAS_MAX, INSTRUCTIONS_MAX;
+var ON_TYPES, DISARMED_TYPE, PR_ACTIONS, PR_CLOSE_ACTIONS, ISSUE_ACTIONS, REVIEW_STATES, REVIEW_ACTION, ID_CHARSET, REPLICAS_MAX, SECRETS_MAX, ENV_NAME, RESERVED_ENV_NAMES, INSTRUCTIONS_MAX;
 var init_triggers = __esm({
   "../worker/src/triggers.mjs"() {
     init_config2();
+    init_flow_gate();
     init_forges();
-    ON_TYPES = /* @__PURE__ */ new Set(["cron", "label", "comment", "pull_request"]);
+    init_reserved_env();
+    ON_TYPES = /* @__PURE__ */ new Set(["cron", "label", "comment", "pull_request", "issue"]);
+    DISARMED_TYPE = "disarmed";
     PR_ACTIONS = {
-      github: /* @__PURE__ */ new Set(["labeled", "opened", "synchronize", "reopened", "review_submitted"]),
+      github: /* @__PURE__ */ new Set(["labeled", "opened", "synchronize", "reopened", "review_submitted", "closed"]),
       // GitLab's `approved` is its review gate (a member approved the MR). It is NOT github's
       // `review_submitted` renamed: `approved` is one verdict, `review_submitted` is every verdict, which is
-      // what `on.reviewState` below exists to narrow.
-      gitlab: /* @__PURE__ */ new Set(["open", "update", "reopen", "approved"]),
+      // what `on.reviewState` below exists to narrow. `close` is GitLab's own spelling of the close action.
+      gitlab: /* @__PURE__ */ new Set(["open", "update", "reopen", "approved", "close"]),
       // Forgejo's own spellings. `label_updated` is its `labeled` and `synchronized` its `synchronize` -- a
       // one-letter difference that an operator would otherwise discover as a trigger that loads clean and
       // never fires. `label_cleared` is deliberately ABSENT and always will be: REMOVING a label must never
       // start a paid run, and it has no GitHub counterpart to inherit that rule from.
-      forgejo: /* @__PURE__ */ new Set(["label_updated", "opened", "synchronized", "reopened"]),
+      forgejo: /* @__PURE__ */ new Set(["label_updated", "opened", "synchronized", "reopened", "closed"]),
       // Azure's Service Hook events reduced to the two that leave something to act on. `git.pullrequest.merged`
-      // is omitted for the same reason GitLab's `merge` and `close` are: a job started by a merge has nothing
-      // left to do. There is no label action at all -- Azure attaches tags to WORK ITEMS, never to pull
-      // requests -- which is why azure's `prLabelAction` is null and a predicated PR rule is refused below.
+      // is omitted for the reason the close words' own comment above records, and there is no close word here at
+      // all: an abandon arrives as `git.pullrequest.updated` with nothing in the projected subset to tell it from
+      // any other update, so an azure close rule could only ever fire on the wrong events or never. Widening
+      // INT-AZURE-PAYLOAD-SUBSET (a PR status field) is the gap to close before this set can grow. There is no
+      // label action either -- Azure attaches tags to WORK ITEMS, never to pull requests -- which is why azure's
+      // `prLabelAction` is null and a predicated PR rule is refused below.
       azure: /* @__PURE__ */ new Set(["created", "updated"])
     };
+    PR_CLOSE_ACTIONS = { github: "closed", gitlab: "close", forgejo: "closed" };
+    ISSUE_ACTIONS = {
+      github: /* @__PURE__ */ new Set(["closed"]),
+      gitlab: /* @__PURE__ */ new Set(["close"]),
+      forgejo: /* @__PURE__ */ new Set(["closed"])
+    };
     REVIEW_STATES = /* @__PURE__ */ new Set(["approved", "changes_requested", "commented"]);
     REVIEW_ACTION = "review_submitted";
     ID_CHARSET = /^[A-Za-z0-9._-]+$/;
     REPLICAS_MAX = 3;
+    SECRETS_MAX = 16;
+    ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+    RESERVED_ENV_NAMES = /* @__PURE__ */ new Set([...MINTED_TOKEN_VARS, ...FORGE_HOST_VARS, ...WORKER_ONLY_SECRET_VARS, ...EGRESS_ENV_VARS, ...CONTAINER_ENV_NAMES]);
     INSTRUCTIONS_MAX = 2e3;
   }
 });
 
-// ../worker/src/pause-windows.mjs
-function isNonEmptyString3(value) {
-  return typeof value === "string" && value.trim() !== "";
-}
-function parseHHMM(value, label, at, path) {
-  const m = isNonEmptyString3(value) ? /^([0-9]{1,2}):([0-9]{2})$/.exec(value.trim()) : null;
-  if (!m) throw configError(`${at}: ${label} must be "HH:MM": ${JSON.stringify(value)} (${path})`);
-  const h = Number(m[1]);
-  const min = Number(m[2]);
-  if (h > 23 || min > 59) throw configError(`${at}: ${label} out of range 00:00-23:59: ${JSON.stringify(value)} (${path})`);
-  return h * 60 + min;
-}
-function assertDate(value, label, at, path) {
-  const m = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(String(value).trim());
-  const mo = m && Number(m[2]);
-  const d = m && Number(m[3]);
-  if (!m || mo < 1 || mo > 12 || d < 1 || d > 31) {
-    throw configError(`${at}: ${label} must be "YYYY-MM-DD": ${JSON.stringify(value)} (${path})`);
-  }
-}
-function validateTz(tz, at, path) {
-  try {
-    new Intl.DateTimeFormat("en-US", { timeZone: tz });
-    return tz;
-  } catch {
-    throw configError(`${at}: tz is not a valid IANA timezone: ${JSON.stringify(tz)} (${path})`);
-  }
-}
-function parsePauseWindows(text, path) {
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch (error) {
-    throw configError(`pause-windows file is not valid JSON: ${path} (${error.message})`);
-  }
-  const windows = parsed?.windows;
-  if (!Array.isArray(windows)) {
-    throw configError(`pause-windows file must have a "windows" array: ${path}`);
-  }
-  return windows.map((w, index) => normalizeWindow(w, index, path));
-}
-function normalizeWindow(w, index, path) {
-  const at = `pause window at index ${index}`;
-  if (w === null || typeof w !== "object") throw configError(`${at}: must be an object: ${path}`);
-  if (!isNonEmptyString3(w.scope)) throw configError(`${at}: scope must be a non-empty string: ${path}`);
-  const fromMin = parseHHMM(w.from, "from", at, path);
-  const toMin = parseHHMM(w.to, "to", at, path);
-  if (fromMin === toMin) {
-    throw configError(`${at}: from and to must differ (a 24h pause is not expressible; remove the trigger): ${path}`);
-  }
-  const tz = w.tz === void 0 ? "UTC" : validateTz(w.tz, at, path);
-  let days = null;
-  if (w.days !== void 0) {
-    if (!Array.isArray(w.days) || w.days.length === 0) {
-      throw configError(`${at}: days must be a non-empty array of weekday names (mon..sun): ${path}`);
-    }
-    days = w.days.map((d) => {
-      const key = String(d).trim().toLowerCase().slice(0, 3);
-      if (!DAY_SET.has(key)) throw configError(`${at}: unknown weekday ${JSON.stringify(d)} (use mon..sun): ${path}`);
-      return key;
-    });
-  }
-  let dateFrom = null;
-  let dateTo = null;
-  if (w.dateFrom !== void 0) {
-    assertDate(w.dateFrom, "dateFrom", at, path);
-    dateFrom = String(w.dateFrom).trim();
-  }
-  if (w.dateTo !== void 0) {
-    assertDate(w.dateTo, "dateTo", at, path);
-    dateTo = String(w.dateTo).trim();
-  }
-  if (dateFrom && dateTo && dateFrom > dateTo) throw configError(`${at}: dateFrom must be <= dateTo: ${path}`);
-  const norm = { scope: w.scope.trim(), from: w.from.trim(), to: w.to.trim(), fromMin, toMin, tz };
-  if (days) norm.days = days;
-  if (dateFrom) norm.dateFrom = dateFrom;
-  if (dateTo) norm.dateTo = dateTo;
-  return norm;
-}
-function zonedParts(tz, ms) {
-  const fmt2 = new Intl.DateTimeFormat("en-US", {
-    timeZone: tz,
-    hour12: false,
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    weekday: "short"
-  });
-  const p = {};
-  for (const part of fmt2.formatToParts(new Date(ms))) p[part.type] = part.value;
-  let hh = Number(p.hour);
-  if (hh === 24) hh = 0;
-  return { y: Number(p.year), mo: Number(p.month), d: Number(p.day), hh, mi: Number(p.minute), dow: WEEKDAY_INDEX[p.weekday] };
-}
-function wallToMs(tz, y, mo, d, hh, mi) {
-  const guess = Date.UTC(y, mo - 1, d, hh, mi);
-  const shown = zonedParts(tz, guess);
-  const shownAsUtc = Date.UTC(shown.y, shown.mo - 1, shown.d, shown.hh, shown.mi);
-  return guess - (shownAsUtc - guess);
-}
-function shiftDay(tz, parts, delta) {
-  const noon = wallToMs(tz, parts.y, parts.mo, parts.d, 12, 0);
-  return zonedParts(tz, noon + delta * 864e5);
-}
-function ymd(parts) {
-  return `${String(parts.y).padStart(4, "0")}-${String(parts.mo).padStart(2, "0")}-${String(parts.d).padStart(2, "0")}`;
-}
-function qualifies(w, parts) {
-  if (w.days && !w.days.includes(DAYS[parts.dow])) return false;
-  const date = ymd(parts);
-  if (w.dateFrom && date < w.dateFrom) return false;
-  if (w.dateTo && date > w.dateTo) return false;
-  return true;
-}
-function windowEndAt(w, nowMs) {
-  const p = zonedParts(w.tz, nowMs);
-  const nowMin = p.hh * 60 + p.mi;
-  const endAt = (dateParts) => wallToMs(w.tz, dateParts.y, dateParts.mo, dateParts.d, Math.floor(w.toMin / 60), w.toMin % 60);
-  if (w.fromMin < w.toMin) {
-    if (nowMin >= w.fromMin && nowMin < w.toMin && qualifies(w, p)) return endAt(p);
-    return null;
-  }
-  if (nowMin >= w.fromMin && qualifies(w, p)) return endAt(shiftDay(w.tz, p, 1));
-  if (nowMin < w.toMin && qualifies(w, shiftDay(w.tz, p, -1))) return endAt(p);
-  return null;
-}
-var DAYS, DAY_SET, WEEKDAY_INDEX;
-var init_pause_windows = __esm({
-  "../worker/src/pause-windows.mjs"() {
-    init_config2();
-    DAYS = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
-    DAY_SET = new Set(DAYS);
-    WEEKDAY_INDEX = { Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6 };
-  }
-});
-
-// ../worker/src/subscriptions.mjs
-function isNonEmptyString4(value) {
-  return typeof value === "string" && value.trim() !== "";
-}
-function normalizeGlobs(value, label, at, path) {
-  if (!Array.isArray(value) || value.length === 0) {
-    throw configError(`${at}: ${label} must be a non-empty array of model globs: ${path}`);
-  }
-  return value.map((glob) => {
-    if (typeof glob !== "string" || !MODEL_GLOB_RE.test(glob.trim())) {
-      throw configError(`${at}: ${label} glob ${JSON.stringify(glob)} must match ${MODEL_GLOB_RE} (model-id charset plus "*", max 64 chars): ${path}`);
-    }
-    return glob.trim();
-  });
-}
-function normalizeBool(value, label, at, path, fallback) {
-  if (value === void 0) return fallback;
-  if (typeof value !== "boolean") throw configError(`${at}: ${label} must be a boolean: ${path}`);
-  return value;
-}
-function parseSubscriptions(text, path) {
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch (error) {
-    throw configError(`subscriptions file is not valid JSON: ${path} (${error.message})`);
-  }
-  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw configError(`subscriptions file must be a JSON object: ${path}`);
-  }
-  const version = parsed.version;
-  if (!Number.isInteger(version) || version < 1) {
-    throw configError(`subscriptions file must declare an integer "version" >= 1 (got ${JSON.stringify(version)}): ${path}`);
-  }
-  if (version > SUBSCRIPTIONS_VERSION) {
-    throw configError(`subscriptions file written by a newer pi-dispatch (version ${version}; this build understands ${SUBSCRIPTIONS_VERSION}): ${path}`);
-  }
-  const entries = parsed.subscriptions;
-  if (!Array.isArray(entries)) {
-    throw configError(`subscriptions file must have a "subscriptions" array: ${path}`);
-  }
-  const seenIds = /* @__PURE__ */ new Map();
-  return { version, subscriptions: entries.map((entry, index) => normalizeSubscription(entry, index, path, seenIds)) };
-}
-function normalizeSubscription(entry, index, path, seenIds) {
-  const at = `subscription at index ${index}`;
-  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
-    throw configError(`${at}: must be an object: ${path}`);
-  }
-  if (!isNonEmptyString4(entry.id)) throw configError(`${at}: id must be a non-empty string: ${path}`);
-  const id = entry.id.trim();
-  if (seenIds.has(id)) {
-    throw configError(`${at}: id ${JSON.stringify(id)} is already used by the subscription at index ${seenIds.get(id)}: ${path}`);
-  }
-  seenIds.set(id, index);
-  if (!isNonEmptyString4(entry.vendor)) throw configError(`${at}: vendor must be a non-empty string: ${path}`);
-  if (!isNonEmptyString4(entry.provider)) throw configError(`${at}: provider must be a non-empty string (the pi-ai provider id this plan covers): ${path}`);
-  const models = entry.models === void 0 ? ["*"] : normalizeGlobs(entry.models, "models", at, path);
-  const price = entry.price;
-  if (price === null || typeof price !== "object" || Array.isArray(price)) {
-    throw configError(`${at}: price must be an object { amount, currency, per }: ${path}`);
-  }
-  if (typeof price.amount !== "number" || !Number.isFinite(price.amount) || price.amount <= 0) {
-    throw configError(`${at}: price.amount must be a number > 0: ${path}`);
-  }
-  if (typeof price.currency !== "string" || !/^[A-Z]{3}$/.test(price.currency)) {
-    throw configError(`${at}: price.currency must be a 3-letter uppercase code (e.g. "USD"): ${path}`);
-  }
-  if (price.per !== "month") {
-    throw configError(`${at}: price.per must be "month" (got ${JSON.stringify(price.per)}): ${path}`);
-  }
-  const sharedWithOtherProducts = normalizeBool(entry.sharedWithOtherProducts, "sharedWithOtherProducts", at, path, false);
-  const hypothetical = normalizeBool(entry.hypothetical, "hypothetical", at, path, false);
-  let counterfactualModel = null;
-  if (entry.counterfactualModel !== void 0 && entry.counterfactualModel !== null) {
-    const cm = entry.counterfactualModel;
-    if (typeof cm !== "object" || Array.isArray(cm) || !isNonEmptyString4(cm.provider) || !isNonEmptyString4(cm.id)) {
-      throw configError(`${at}: counterfactualModel must be { provider, id } with non-empty strings (a PRICED pi-ai model to re-price covered runs at API rates): ${path}`);
-    }
-    counterfactualModel = { provider: cm.provider.trim(), id: cm.id.trim() };
-  }
-  let windows = [];
-  if (entry.windows !== void 0) {
-    if (!Array.isArray(entry.windows)) throw configError(`${at}: windows must be an array: ${path}`);
-    windows = entry.windows.map((w, windowIndex) => normalizeWindow2(w, windowIndex, index, path));
-  }
-  return {
-    id,
-    vendor: entry.vendor.trim(),
-    provider: entry.provider.trim(),
-    models,
-    price: { amount: price.amount, currency: price.currency, per: "month" },
-    sharedWithOtherProducts,
-    hypothetical,
-    counterfactualModel,
-    windows
-  };
-}
-function normalizeWindow2(w, windowIndex, subIndex, path) {
-  const at = `window at index ${windowIndex} of subscription at index ${subIndex}`;
-  if (w === null || typeof w !== "object" || Array.isArray(w)) {
-    throw configError(`${at}: must be an object: ${path}`);
-  }
-  if (!WINDOW_PERS.has(w.per)) {
-    throw configError(`${at}: per must be one of 5h|7d|30d|month (got ${JSON.stringify(w.per)}): ${path}`);
-  }
-  const rolling = normalizeBool(w.rolling, "rolling", at, path, false);
-  let unit = null;
-  if (w.unit !== void 0 && w.unit !== null) {
-    if (!WINDOW_UNITS.has(w.unit)) {
-      throw configError(`${at}: unit must be one of tokens|requests|prompts|credits, or null (vendor undisclosed): ${path}`);
-    }
-    unit = w.unit;
-  }
-  let limit = null;
-  if (w.limit !== void 0 && w.limit !== null) {
-    if (typeof w.limit === "number") {
-      if (!Number.isFinite(w.limit) || w.limit <= 0) throw configError(`${at}: limit must be a number > 0, [min, max], or null (vendor undisclosed): ${path}`);
-      limit = w.limit;
-    } else if (Array.isArray(w.limit)) {
-      const [min, max] = w.limit;
-      if (w.limit.length !== 2 || typeof min !== "number" || typeof max !== "number" || !Number.isFinite(min) || !Number.isFinite(max) || min <= 0 || max <= 0 || min >= max) {
-        throw configError(`${at}: limit range must be [min, max] with both > 0 and min < max: ${path}`);
-      }
-      limit = [min, max];
-    } else {
-      throw configError(`${at}: limit must be a number > 0, [min, max], or null (vendor undisclosed): ${path}`);
-    }
-  }
-  const scope = w.scope === void 0 || w.scope === null ? null : normalizeGlobs(w.scope, "scope", at, path);
-  return { per: w.per, rolling, unit, limit, scope };
-}
-var SUBSCRIPTIONS_VERSION, WINDOW_PERS, WINDOW_UNITS, MODEL_GLOB_RE;
-var init_subscriptions = __esm({
-  "../worker/src/subscriptions.mjs"() {
-    init_config2();
-    SUBSCRIPTIONS_VERSION = 1;
-    WINDOW_PERS = /* @__PURE__ */ new Set(["5h", "7d", "30d", "month"]);
-    WINDOW_UNITS = /* @__PURE__ */ new Set(["tokens", "requests", "prompts", "credits"]);
-    MODEL_GLOB_RE = /^[A-Za-z0-9*._:/-]{1,64}$/;
-  }
-});
-
-// ../worker/src/connection.mjs
-import { Redis } from "ioredis";
-function parseConnection(url, { failFast = false } = {}) {
-  const u = new URL(url);
-  return {
-    host: u.hostname || "127.0.0.1",
-    port: Number(u.port || 6379),
-    ...u.password ? { password: u.password } : {},
-    ...u.username ? { username: u.username } : {},
-    ...u.pathname && u.pathname !== "/" ? { db: Number(u.pathname.slice(1)) } : {},
-    maxRetriesPerRequest: null,
-    // required for BullMQ blocking connections
-    ...failFast ? {
-      connectTimeout: 2e3,
-      enableOfflineQueue: false,
-      // don't buffer commands while disconnected -- error now
-      retryStrategy: (attempts) => attempts > 2 ? null : 200
-      // give up after ~2 tries
-    } : {}
-  };
-}
-function makeRedisClient(url) {
-  return new Redis(url, { maxRetriesPerRequest: null });
-}
-var init_connection = __esm({
-  "../worker/src/connection.mjs"() {
-  }
-});
-
-// ../worker/src/job-id.mjs
-import { createHash } from "node:crypto";
-function localJobId({ folder, flow, task, minute }) {
-  const digest = createHash("sha256").update([folder, flow ?? "", task ?? "", minute].join("\0")).digest("hex");
-  return `local-${digest.slice(0, 16)}`;
-}
-var init_job_id = __esm({
-  "../worker/src/job-id.mjs"() {
-    init_config2();
-    init_forges();
-  }
-});
-
 // ../worker/src/queue.mjs
 import { Queue } from "bullmq";
 function makeQueue(connection) {
   return new Queue(QUEUE, { connection });
 }
-async function enqueueLocalJob(queue, { folder, flow, task, command, provider, model, maxTurns, image, skillsDir, chainDepth, parentJobId, jobId, now = /* @__PURE__ */ new Date() }) {
+async function enqueueLocalJob(queue, { folder, flow, task, command, provider, model, maxTurns, image, skillsDir, secrets, secretsProfile, chainDepth, parentJobId, jobId, now = /* @__PURE__ */ new Date() }) {
   const minute = now.toISOString().slice(0, 16);
   const id = jobId ?? localJobId({ folder, flow: command !== void 0 ? `cmd:${command}` : flow, task, minute });
   const data = {
@@ -8574,6 +8882,11 @@ async function enqueueLocalJob(queue, { folder, flow, task, command, provider, m
     // than inside `trigger` because a worker-host path is an execution knob, not a fact about the
     // delivery -- and `trigger` is the object copied into /job/event.json.
     ...skillsDir !== void 0 && { skillsDir },
+    // REQ-TRIGGER-SECRETS, on the forge path's terms: references only, resolved by the worker at job
+    // start. A cron trigger may bind secrets (a nightly deploy is the obvious user), which is where
+    // this differs from `replicas` -- that one is refused on a local job and this one is not.
+    ...secrets !== void 0 && { secrets },
+    ...secretsProfile !== void 0 && { secretsProfile },
     ...chainDepth !== void 0 && { chainDepth },
     ...parentJobId !== void 0 && { parentJobId }
   };
@@ -8586,59 +8899,18 @@ async function enqueueLocalJob(queue, { folder, flow, task, command, provider, m
   });
   return id;
 }
-var QUEUE, SEMANTIC_WINDOW_MS;
+var PR_CLOSE_WORDS, QUEUE, SEMANTIC_WINDOW_MS;
 var init_queue = __esm({
   "../worker/src/queue.mjs"() {
     init_job_id();
     init_forges();
+    init_triggers();
+    PR_CLOSE_WORDS = new Set(Object.values(PR_CLOSE_ACTIONS));
     QUEUE = "pi-jobs";
     SEMANTIC_WINDOW_MS = 10 * 60 * 1e3;
   }
 });
 
-// ../worker/src/flow-gate.mjs
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-async function readFlowGate({ folder, flow, sha, git = defaultGit }) {
-  if (typeof sha !== "string" || sha.trim() === "") return { gate: "deny" };
-  if (typeof flow !== "string" || !SKILL_NAME_RE.test(flow)) return { gate: "deny" };
-  const path = `.pi/skills/${flow}/SKILL.md`;
-  try {
-    const lsTreeZ = await git(folder, ["ls-tree", "-z", sha, path]);
-    const record = lsTreeZ.split("\0").find((r) => r);
-    if (!record) return { gate: "no-skill" };
-    const tab = record.indexOf("	");
-    if (tab === -1) return { gate: "deny" };
-    const [mode, type, oid] = record.slice(0, tab).split(/\s+/);
-    if (mode !== "100644" || type !== "blob") return { gate: "deny" };
-    const content = await git(folder, ["cat-file", "blob", oid], { raw: true });
-    return { gate: aiTriggerAllows(content) ? "allow" : "deny" };
-  } catch {
-    return { gate: "deny" };
-  }
-}
-function aiTriggerAllows(buf) {
-  const text = buf.toString("utf8").replace(/^\uFEFF/, "").replace(/\r\n/g, "\n");
-  const block = /^---\n([\s\S]*?)\n---(?:\n|$)/.exec(text);
-  if (!block) return false;
-  return /^ai-trigger:\s*("?)allow\1\s*$/m.test(block[1]);
-}
-async function defaultGit(gitDir, args, { raw = false } = {}) {
-  const hardened = ["-c", "core.hooksPath=/dev/null", "-c", "core.fsmonitor=false", "--no-pager", "-C", gitDir, ...args];
-  const { stdout } = await exec("git", hardened, {
-    encoding: raw ? "buffer" : "utf8",
-    maxBuffer: 16 * 1024 * 1024
-  });
-  return stdout;
-}
-var exec, SKILL_NAME_RE;
-var init_flow_gate = __esm({
-  "../worker/src/flow-gate.mjs"() {
-    exec = promisify(execFile);
-    SKILL_NAME_RE = /^[a-z0-9](?:[a-z0-9_-]{0,62}[a-z0-9])?$/;
-  }
-});
-
 // ../worker/src/git-dirty.mjs
 import { execFileSync } from "node:child_process";
 function gitDirty(folder, { exec: exec4 = execFileSync } = {}) {
@@ -9216,6 +9488,16 @@ function buildGraphModel({ triggers, schedulers, folderSkills, injectedSkills, o
       // (guarded on `typeof t.flow === "string"`) correctly draws nothing for it.
       command: t.command ?? null,
       replicas: t.replicas ?? null,
+      // The one-shot facts (issue #231), carried the way `cost` is: node FACTS, never new vocabulary
+      // -- the #188 rule, and GRAPH_FLAGS/GRAPH_NODE_KINDS are byte-unchanged by this issue too. A
+      // spent entry still arrives here because the display normalizer reads the RAW file (the spent
+      // row must stay visible), so the two states a renderer has to keep apart ride as one boolean
+      // and one mark: `once` is true only while ARMED -- a spent one-shot is not "a rule that will
+      // fire once", and letting both read true would ask every consumer to re-derive the difference
+      // -- and `disarmed` is the worker's mark verbatim ({ at, jobId? }), null like every absent
+      // fact on this literal.
+      once: t.once === true && !t.disarmed,
+      disarmed: t.disarmed !== null && typeof t.disarmed === "object" ? t.disarmed : null,
       folderKey: group?.key ?? null,
       runs: Number.isInteger(stats?.runs) ? stats.runs : 0,
       lastOutcome: stats?.lastOutcome ?? null,
@@ -9353,8 +9635,16 @@ function triggerMatchLabel(t) {
       return selectorLabel(t);
     case "comment":
       return `"${t.phrase ?? "-"}"`;
-    case "pull_request":
-      return `action[${(Array.isArray(t.action) ? t.action : []).join(",")}]`;
+    case "pull_request": {
+      const action = `action[${(Array.isArray(t.action) ? t.action : []).join(",")}]`;
+      const num = Number.isInteger(t.number) ? ` #${t.number}` : "";
+      return t.disarmed ? `${action}${num} (spent)` : `${action}${num}`;
+    }
+    case "issue": {
+      const action = `action[${(Array.isArray(t.action) ? t.action : []).join(",")}]`;
+      const base = Number.isInteger(t.number) ? `${action} #${t.number}` : action;
+      return t.disarmed ? `${base} (spent)` : base;
+    }
     default:
       return "(unknown)";
   }
@@ -9961,8 +10251,110 @@ var init_costs = __esm({
   }
 });
 
+// ../worker/src/triggers-file.mjs
+import nodeFs2 from "node:fs";
+function lockPathFor(triggersPath) {
+  return `${triggersPath}.lock`;
+}
+function takeLock(triggersPath, fs, log) {
+  const lock = lockPathFor(triggersPath);
+  let sweptAgeMs = null;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const fd = fs.openSync(lock, "wx");
+      if (sweptAgeMs !== null) log("triggers_lock_stale_taken", { ageMs: sweptAgeMs });
+      return fd;
+    } catch (err) {
+      if (err?.code !== "EEXIST") throw err;
+      let mtimeMs;
+      try {
+        mtimeMs = fs.statSync(lock).mtimeMs;
+      } catch {
+        continue;
+      }
+      if (Date.now() - mtimeMs <= LOCK_STALE_MS) return null;
+      try {
+        fs.unlinkSync(lock);
+      } catch {
+      }
+      sweptAgeMs = Math.round(Date.now() - mtimeMs);
+    }
+  }
+  return null;
+}
+function releaseLock(fd, triggersPath, fs, log) {
+  fs.closeSync(fd);
+  try {
+    fs.unlinkSync(lockPathFor(triggersPath));
+  } catch {
+    log("triggers_lock_stuck", {});
+  }
+}
+function serialize(triggersArray) {
+  return `${JSON.stringify({ triggers: triggersArray }, null, 2)}
+`;
+}
+function renameIntoPlace(fs, tmp, dest) {
+  try {
+    fs.renameSync(tmp, dest);
+  } catch (err) {
+    if (err?.code !== "EPERM") throw err;
+    fs.renameSync(tmp, dest);
+  }
+}
+function tmpPathFor(triggersPath) {
+  return `${triggersPath}.${process.pid}.${tmpSeq++}.tmp`;
+}
+function discardTmp(fs, tmp) {
+  try {
+    fs.unlinkSync(tmp);
+  } catch {
+  }
+}
+function writeTriggers({ triggersPath, mutate, fs = nodeFs2, log = () => {
+} }) {
+  const fd = takeLock(triggersPath, fs, log);
+  if (fd === null) {
+    return { invalid: `triggers file locked (another write in progress): ${lockPathFor(triggersPath)}` };
+  }
+  try {
+    let current = [];
+    try {
+      const raw = JSON.parse(fs.readFileSync(triggersPath, "utf8"));
+      if (Array.isArray(raw?.triggers)) current = raw.triggers;
+    } catch {
+    }
+    const next = mutate(current.map((t) => ({ ...t })));
+    const text = serialize(next);
+    try {
+      parseTriggers(text, triggersPath);
+    } catch (e) {
+      return { invalid: e?.message ?? String(e) };
+    }
+    const tmp = tmpPathFor(triggersPath);
+    try {
+      fs.writeFileSync(tmp, text, { mode: 420 });
+      renameIntoPlace(fs, tmp, triggersPath);
+    } catch (err) {
+      discardTmp(fs, tmp);
+      throw err;
+    }
+    return { ok: true };
+  } finally {
+    releaseLock(fd, triggersPath, fs, log);
+  }
+}
+var LOCK_STALE_MS, tmpSeq;
+var init_triggers_file = __esm({
+  "../worker/src/triggers-file.mjs"() {
+    init_triggers();
+    LOCK_STALE_MS = 1e4;
+    tmpSeq = 0;
+  }
+});
+
 // src/read-model.mjs
-import * as nodeFs2 from "node:fs";
+import * as nodeFs3 from "node:fs";
 import { join as join2, delimiter, sep } from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
 function resolvePaths(env = process.env) {
@@ -10135,14 +10527,14 @@ function folderUnderRoots(folder, roots) {
   if (!Array.isArray(roots) || roots.length === 0) return false;
   let realTarget;
   try {
-    realTarget = nodeFs2.realpathSync(folder);
+    realTarget = nodeFs3.realpathSync(folder);
   } catch {
     return false;
   }
   for (const root of roots) {
     let realRoot;
     try {
-      realRoot = nodeFs2.realpathSync(root);
+      realRoot = nodeFs3.realpathSync(root);
     } catch {
       continue;
     }
@@ -10153,7 +10545,7 @@ function folderUnderRoots(folder, roots) {
 function hourKey(nowMs) {
   return `dispatch-run:${new Date(nowMs).toISOString().slice(0, 13).replace("T", "-")}`;
 }
-function writeSettings({ settingsFile, mutate, fs = nodeFs2 }) {
+function writeSettings({ settingsFile, mutate, fs = nodeFs3 }) {
   const res = readOverlay(settingsFile, { fs });
   const base = res.overlay ?? {};
   const next = mutate({ ...base });
@@ -10161,27 +10553,7 @@ function writeSettings({ settingsFile, mutate, fs = nodeFs2 }) {
   if (w.invalid) return { invalid: w.invalid };
   return res.invalid ? { ok: true, overlay: next, rebuiltFrom: res.invalid } : { ok: true, overlay: next };
 }
-function writeTriggers({ triggersPath, mutate, fs = nodeFs2 }) {
-  let current = [];
-  try {
-    const raw = JSON.parse(fs.readFileSync(triggersPath, "utf8"));
-    if (Array.isArray(raw?.triggers)) current = raw.triggers;
-  } catch {
-  }
-  const next = mutate(current.map((t) => ({ ...t })));
-  const text = `${JSON.stringify({ triggers: next }, null, 2)}
-`;
-  try {
-    parseTriggers(text, triggersPath);
-  } catch (e) {
-    return { invalid: e?.message ?? String(e) };
-  }
-  const tmp = `${triggersPath}.tmp`;
-  fs.writeFileSync(tmp, text, { mode: 420 });
-  fs.renameSync(tmp, triggersPath);
-  return { ok: true };
-}
-function readPauseWindows({ pauseWindowsPath, fs = nodeFs2 }) {
+function readPauseWindows({ pauseWindowsPath, fs = nodeFs3 }) {
   let text;
   try {
     text = fs.readFileSync(pauseWindowsPath, "utf8");
@@ -10194,7 +10566,7 @@ function readPauseWindows({ pauseWindowsPath, fs = nodeFs2 }) {
     return { invalid: e?.message ?? String(e) };
   }
 }
-function writePauseWindows({ pauseWindowsPath, mutate, fs = nodeFs2 }) {
+function writePauseWindows({ pauseWindowsPath, mutate, fs = nodeFs3 }) {
   let current = [];
   try {
     const raw = JSON.parse(fs.readFileSync(pauseWindowsPath, "utf8"));
@@ -10214,7 +10586,7 @@ function writePauseWindows({ pauseWindowsPath, mutate, fs = nodeFs2 }) {
   fs.renameSync(tmp, pauseWindowsPath);
   return { ok: true };
 }
-function readSubscriptions({ subscriptionsPath, fs = nodeFs2 }) {
+function readSubscriptions({ subscriptionsPath, fs = nodeFs3 }) {
   if (subscriptionsPath === null || subscriptionsPath === void 0) return { missing: true };
   let text;
   try {
@@ -10296,7 +10668,7 @@ function withTimeout(promise, ms, fallback) {
   });
   return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
 }
-function listRuns({ logsDir, limit = 10, fs = nodeFs2 }) {
+function listRuns({ logsDir, limit = 10, fs = nodeFs3 }) {
   const cap = clampLimit(limit);
   let names;
   try {
@@ -10314,7 +10686,7 @@ function listRuns({ logsDir, limit = 10, fs = nodeFs2 }) {
   records.sort(byEndedAtDesc);
   return records.slice(0, cap);
 }
-function scanRunRecords({ logsDir, sinceMs, nowMs = Date.now(), fs = nodeFs2 }) {
+function scanRunRecords({ logsDir, sinceMs, nowMs = Date.now(), fs = nodeFs3 }) {
   const oldestMs = nowMs - SCAN_WINDOW_MAX_DAYS * 24 * 60 * 60 * 1e3;
   const cutoffMs = Math.max(Number.isFinite(sinceMs) ? sinceMs : oldestMs, oldestMs);
   let names;
@@ -10335,27 +10707,26 @@ function scanRunRecords({ logsDir, sinceMs, nowMs = Date.now(), fs = nodeFs2 })
   }
   return records;
 }
-function readRun({ logsDir, jobId, fs = nodeFs2 }) {
+function readRun({ logsDir, jobId, fs = nodeFs3 }) {
   return readJsonFile(join2(logsDir, `${sanitizeJobId(jobId)}.json`), fs);
 }
-function readLogTail({ logsDir, jobId, lines = 200, fs = nodeFs2 }) {
+function readLogTail({ logsDir, jobId, lines = 200, fs = nodeFs3 }) {
   let text;
   try {
     text = fs.readFileSync(join2(logsDir, `${sanitizeJobId(jobId)}.log`), "utf8");
   } catch {
     return { missing: true };
   }
-  const all = text.split("\n");
-  if (all.length > 0 && all[all.length - 1] === "") all.pop();
+  const all = text.split("\n").filter((line) => line !== "");
   const cap = clampLines(lines);
   return { lines: all.slice(Math.max(0, all.length - cap)) };
 }
-function readSettingsView({ settingsFile, fs = nodeFs2 }) {
+function readSettingsView({ settingsFile, fs = nodeFs3 }) {
   const result = readOverlay(settingsFile, { fs });
   if (result.invalid) return { path: settingsFile, invalid: result.invalid };
   return { path: settingsFile, overlay: result.overlay };
 }
-function readTriggers({ triggersPath, fs = nodeFs2 }) {
+function readTriggers({ triggersPath, fs = nodeFs3 }) {
   let text;
   try {
     text = fs.readFileSync(triggersPath, "utf8");
@@ -10393,6 +10764,8 @@ function normalizeTriggerForDisplay(entry) {
   const resume = run.resume === true;
   const forge = typeof run.kind === "string" && run.kind.trim() !== "" ? run.kind : null;
   const replicas = Number.isInteger(run.replicas) && run.replicas > 1 ? run.replicas : null;
+  const secrets = run.secrets !== null && typeof run.secrets === "object" && !Array.isArray(run.secrets) ? Object.keys(run.secrets).length : 0;
+  const secretsProfile = typeof run.secretsProfile === "string" && run.secretsProfile.trim() !== "" ? run.secretsProfile : null;
   switch (on.type) {
     case "cron":
       return {
@@ -10409,19 +10782,25 @@ function normalizeTriggerForDisplay(entry) {
         image,
         skillsDir,
         instructions,
-        resume
+        resume,
+        secrets,
+        secretsProfile
       };
     case "label":
-      return { type: "label", any: normalizeSelector(on.any), all: normalizeSelector(on.all), none: normalizeSelector(on.none), flow, command, packages, image, skillsDir, instructions, resume, replicas, forge };
+      return { type: "label", any: normalizeSelector(on.any), all: normalizeSelector(on.all), none: normalizeSelector(on.none), flow, command, packages, image, skillsDir, instructions, resume, secrets, secretsProfile, replicas, forge };
     case "comment":
-      return { type: "comment", phrase: typeof on.phrase === "string" ? on.phrase : null, flow, command, packages, image, skillsDir, instructions, resume, replicas, forge };
-    case "pull_request":
+      return { type: "comment", phrase: typeof on.phrase === "string" ? on.phrase : null, flow, command, packages, image, skillsDir, instructions, resume, secrets, secretsProfile, replicas, forge };
+    case "pull_request": {
+      const prDisarmed = on.disarmed !== null && typeof on.disarmed === "object" && !Array.isArray(on.disarmed) ? on.disarmed : null;
       return {
         type: "pull_request",
         action: normalizeSelector(on.action),
         any: normalizeSelector(on.any),
         all: normalizeSelector(on.all),
         none: normalizeSelector(on.none),
+        ...Number.isInteger(on.number) && on.number >= 1 && { number: on.number },
+        ...on.once === true && { once: true },
+        ...prDisarmed !== null && { disarmed: prDisarmed },
         flow,
         command,
         packages,
@@ -10429,9 +10808,39 @@ function normalizeTriggerForDisplay(entry) {
         skillsDir,
         instructions,
         resume,
+        secrets,
+        secretsProfile,
         replicas,
         forge
       };
+    }
+    case "issue": {
+      const disarmed = on.disarmed !== null && typeof on.disarmed === "object" && !Array.isArray(on.disarmed) ? on.disarmed : null;
+      return {
+        type: "issue",
+        action: normalizeSelector(on.action),
+        // `null` is the every-item sentinel, this function's own flow/model/phrase convention; the loader
+        // refused anything but an integer >= 1, so the display mirrors rather than re-validates.
+        number: Number.isInteger(on.number) && on.number >= 1 ? on.number : null,
+        // An opt-IN, `=== true` like `resume` above and NOT `!== false`: the rendering mistake that costs
+        // is a one-shot with no marker, never a standing rule with a spurious one.
+        once: on.once === true,
+        // Absent, not null, when unspent: `disarmed` is a mark the worker adds, and a key that is usually
+        // missing reads truer than a fifth null sentinel -- consumers test presence, not value.
+        ...disarmed !== null && { disarmed },
+        flow,
+        command,
+        packages,
+        image,
+        skillsDir,
+        instructions,
+        resume,
+        secrets,
+        secretsProfile,
+        replicas,
+        forge
+      };
+    }
     default:
       return null;
   }
@@ -10440,7 +10849,7 @@ function normalizeSelector(value) {
   if (!Array.isArray(value)) return [];
   return value.filter((member) => typeof member === "string");
 }
-function readStagedPackages({ globalPiDir, fs = nodeFs2, readManifest: readManifest2 = readStageManifest } = {}) {
+function readStagedPackages({ globalPiDir, fs = nodeFs3, readManifest: readManifest2 = readStageManifest } = {}) {
   const empty = { stagedAt: null, packages: [] };
   if (typeof globalPiDir !== "string" || globalPiDir === "") return empty;
   let manifest;
@@ -10648,7 +11057,7 @@ function readFolderSkills({ folder, exec: exec4 = execFileSync2 } = {}) {
   }
   return { head, skills, truncated: truncated || anyUnread, unreachable: null };
 }
-function readInjectedSkills({ skillsDir, fs = nodeFs2 } = {}) {
+function readInjectedSkills({ skillsDir, fs = nodeFs3 } = {}) {
   if (typeof skillsDir !== "string" || skillsDir === "") return { skills: [], truncated: false, unreachable: null };
   let names;
   try {
@@ -10671,7 +11080,7 @@ function readInjectedSkills({ skillsDir, fs = nodeFs2 } = {}) {
   }
   return { skills, truncated, unreachable: null };
 }
-function readOverlaySkills({ globalPiDir, fs = nodeFs2 } = {}) {
+function readOverlaySkills({ globalPiDir, fs = nodeFs3 } = {}) {
   if (typeof globalPiDir !== "string" || globalPiDir === "") return { skills: [], truncated: false, unreachable: null };
   const dir = join2(globalPiDir, "skills");
   let names;
@@ -10695,7 +11104,7 @@ function readOverlaySkills({ globalPiDir, fs = nodeFs2 } = {}) {
   }
   return { skills, truncated, unreachable: null };
 }
-function readStagedSkillsList({ globalPiDir, fs = nodeFs2, readStaged = readStagedSkills } = {}) {
+function readStagedSkillsList({ globalPiDir, fs = nodeFs3, readStaged = readStagedSkills } = {}) {
   const empty = { skills: [], unenumerable: [], truncated: false };
   if (typeof globalPiDir !== "string" || globalPiDir === "") return empty;
   let result;
@@ -10770,7 +11179,7 @@ function forgeRepoTargets({ records } = {}) {
 function escapeRegExp2(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function listRunIds({ logsDir, fs = nodeFs2 }) {
+function listRunIds({ logsDir, fs = nodeFs3 }) {
   let names;
   try {
     names = fs.readdirSync(logsDir);
@@ -10815,7 +11224,6 @@ var init_read_model = __esm({
     init_runtime_settings();
     init_run_history();
     init_budget();
-    init_triggers();
     init_pause_windows();
     init_subscriptions();
     init_connection();
@@ -10827,6 +11235,7 @@ var init_read_model = __esm({
     init_forges();
     init_graph_model();
     init_costs();
+    init_triggers_file();
     DISPATCH_RUN_TTL_SECONDS = 2 * 60 * 60;
     SCAN_WINDOW_MAX_DAYS = 92;
     GRAPH_LIMITS = Object.freeze({
@@ -10945,6 +11354,12 @@ function normalizeModel(model) {
       package: typeof n.package === "string" ? clip(n.package, 80) : null,
       tiersUnknown: Array.isArray(n.tiersUnknown) ? [...new Set(n.tiersUnknown.filter((t) => typeof t === "string").map((t) => clip(t, 40)))].sort().slice(0, 4) : [],
       replicas: intOr(n.replicas, null),
+      // One-shot facts (#231): `once` is the armed state, and the disarm mark is narrowed to its
+      // instant alone. The mark's jobId stays server-side on purpose: the page answers "spent, and
+      // when", and provenance beyond that belongs to the operator's own console -- a shareable
+      // file:// page should carry no more of a deployment's run history than the question needs.
+      once: n.once === true,
+      disarmed: n.disarmed !== null && n.disarmed !== void 0 && typeof n.disarmed === "object" && !Array.isArray(n.disarmed) ? { at: typeof n.disarmed.at === "string" ? clip(n.disarmed.at, 40) : Number.isFinite(n.disarmed.at) ? n.disarmed.at : null } : null,
       folderKey: typeof n.folderKey === "string" ? n.folderKey : null,
       runs: intOr(n.runs, 0),
       lastOutcome: typeof n.lastOutcome === "string" ? n.lastOutcome : null,
@@ -11389,6 +11804,8 @@ function buildTip(n, flags, groupLabel, nowMs) {
       const nextMs = typeof n.next === "number" ? n.next : typeof n.next === "string" ? Date.parse(n.next) : NaN;
       if (Number.isFinite(nextMs) && Number.isFinite(nowMs) && nextMs > nowMs) lines.push(`next ${relSpan(nextMs - nowMs)}`);
     }
+    if (n.disarmed !== null) lines.push(`one-shot, spent${n.disarmed.at !== null ? ` ${n.disarmed.at}` : ""}`);
+    else if (n.once) lines.push("one-shot (armed)");
   }
   if (n.aiTrigger) lines.push("chainable: ai-trigger allow");
   if (n.kind === "skill" && n.loops.length > 0) {
@@ -11419,6 +11836,7 @@ function nodeState(n, flagNames) {
   }
   if (n.kind === "skill-unverified") return { stroke: PAGE_DIM, dash: "10,4", faded: false };
   if (n.kind === "skill-not-at-head") return { stroke: PAGE_AMBER, dash: "10,4", faded: false };
+  if (n.kind === "trigger" && n.disarmed !== null) return { stroke: CHIP_STROKE, dash: "8,3", faded: true };
   if (flagNames.has("orphan")) return { stroke: CHIP_STROKE, dash: "8,3", faded: true };
   return { stroke: CHIP_STROKE, dash: null, faded: false };
 }
@@ -11663,6 +12081,7 @@ var init_graph_html = __esm({
       label: "#d8bfd8",
       comment: "#e7e7ae",
       pull_request: "#c0deed",
+      issue: "#c7e9c0",
       skill: "#fdd0a2"
     });
     STATUS_COMPLETED = "#3fb950";
@@ -11692,6 +12111,7 @@ var init_graph_html = __esm({
       label: "\u25C8",
       comment: "\u275D",
       pull_request: "\u21C4",
+      issue: "\u25C9",
       skill: "\u0192",
       "skill-missing": "!",
       "skill-unverified": "?",
@@ -13106,7 +13526,7 @@ var init_open_browser = __esm({
 });
 
 // src/deployment-pointer.mjs
-import * as nodeFs3 from "node:fs";
+import * as nodeFs4 from "node:fs";
 import { homedir } from "node:os";
 import { join as join3, isAbsolute } from "node:path";
 function pointerPath(env = process.env) {
@@ -13138,7 +13558,7 @@ function normalizePointer(raw) {
   }
   return { pointer: { version: raw.version, deploymentDir: raw.deploymentDir, env } };
 }
-function readPointer({ path = pointerPath(), fs = nodeFs3 } = {}) {
+function readPointer({ path = pointerPath(), fs = nodeFs4 } = {}) {
   let text;
   try {
     text = fs.readFileSync(path, "utf8");
@@ -13171,12 +13591,12 @@ function layerPointer(env, fs) {
   }
   return { applied };
 }
-function applyDeploymentPointer(env = process.env, { fs = nodeFs3 } = {}) {
+function applyDeploymentPointer(env = process.env, { fs = nodeFs4 } = {}) {
   if (appliedOnce) return { applied: [] };
   appliedOnce = true;
   return layerPointer(env, fs);
 }
-function reapplyDeploymentPointer(env = process.env, { fs = nodeFs3 } = {}) {
+function reapplyDeploymentPointer(env = process.env, { fs = nodeFs4 } = {}) {
   appliedOnce = true;
   return layerPointer(env, fs);
 }
@@ -13185,7 +13605,7 @@ function takePointerNotice() {
   notice = void 0;
   return n;
 }
-function writePointer({ path = pointerPath(), pointer, fs = nodeFs3 } = {}) {
+function writePointer({ path = pointerPath(), pointer, fs = nodeFs4 } = {}) {
   const res = normalizePointer(pointer);
   if (res.ignored) return { invalid: res.ignored };
   const tmp = `${path}.tmp`;
@@ -38917,17 +39337,25 @@ function triggerLine(t) {
   const ins = t?.instructions === true ? "  [instructions]" : "";
   const res = t?.resume === true ? "  [resume]" : "";
   const rep = t?.replicas > 1 ? `  [x${t.replicas}]` : "";
+  const sec = t?.secrets > 0 ? `  [secrets ${t.secrets}${t.secretsProfile ? ` via ${t.secretsProfile}` : ""}]` : "";
+  const shot = t?.disarmed ? "  [spent]" : t?.once === true ? "  [once]" : "";
   switch (t?.type) {
     case "cron":
-      return `cron  ${t.id ?? "-"}  ${t.pattern ?? "-"} \u2192 ${t.folder ?? "-"}/${flow}${forge}${pkgs}${img}${skl}${ins}${res}${rep}`;
+      return `cron  ${t.id ?? "-"}  ${t.pattern ?? "-"} \u2192 ${t.folder ?? "-"}/${flow}${forge}${pkgs}${img}${skl}${ins}${res}${rep}${sec}`;
     case "label":
-      return `label  ${ruleClauses(t) || "(no selector)"} \u2192 ${flow}${forge}${pkgs}${img}${skl}${ins}${res}${rep}`;
+      return `label  ${ruleClauses(t) || "(no selector)"} \u2192 ${flow}${forge}${pkgs}${img}${skl}${ins}${res}${rep}${sec}`;
     case "comment":
-      return `comment  "${t.phrase ?? "-"}" \u2192 ${flow}${forge}${pkgs}${img}${skl}${ins}${res}${rep}`;
+      return `comment  "${t.phrase ?? "-"}" \u2192 ${flow}${forge}${pkgs}${img}${skl}${ins}${res}${rep}${sec}`;
     case "pull_request": {
       const clauses = ruleClauses(t);
       const action = `action[${(t.action ?? []).join(",")}]`;
-      return `pull_request  ${action}${clauses ? ` ${clauses}` : ""} \u2192 ${flow}${forge}${pkgs}${img}${skl}${ins}${res}${rep}`;
+      const num = Number.isInteger(t.number) ? ` #${t.number}` : "";
+      return `pull_request  ${action}${num}${clauses ? ` ${clauses}` : ""} \u2192 ${flow}${forge}${pkgs}${img}${skl}${ins}${res}${rep}${sec}${shot}`;
+    }
+    case "issue": {
+      const action = `action[${(t.action ?? []).join(",")}]`;
+      const num = Number.isInteger(t.number) ? ` #${t.number}` : "";
+      return `issue  ${action}${num} \u2192 ${flow}${forge}${pkgs}${img}${skl}${ins}${res}${rep}${sec}${shot}`;
     }
     default:
       return "(unknown trigger)";
@@ -39856,8 +40284,9 @@ function triggerRow(t, sel, inner, styler, sched = null) {
   const img = t?.image ? " " + styler.fg("accent", `[${t.image}]`) : "";
   const res = t?.resume === true ? " " + styler.fg("warning", "[resume]") : "";
   const rep = t?.replicas > 1 ? " " + styler.fg("warning", `[x${t.replicas}]`) : "";
+  const shot = t?.disarmed ? " " + styler.fg("dim", "[spent]") : t?.once === true ? " " + styler.fg("accent", "[once]") : "";
   const health = sched && (sched.overdueMs || sched.stallMax > 0 && sched.stalls >= sched.stallMax) ? " " + styler.fg("warning", sched.overdueMs ? "\u26A0 overdue" : "\u26A0 stalled") : "";
-  return fitLine(`${cursor} ${badge} ${matchColored(t, styler)} ${targetColored(t, styler)}${pkgs}${img}${res}${rep}${health}`, inner, styler);
+  return fitLine(`${cursor} ${badge} ${matchColored(t, styler)} ${targetColored(t, styler)}${pkgs}${img}${res}${rep}${shot}${health}`, inner, styler);
 }
 function matchColored(t, styler) {
   switch (t?.type) {
@@ -39865,10 +40294,15 @@ function matchColored(t, styler) {
       return styler.fg("text", `${t.id ?? "-"}  ${t.pattern ?? "-"}`);
     case "comment":
       return styler.fg("text", `"${t.phrase ?? "-"}"`);
+    case "issue": {
+      const num = Number.isInteger(t.number) ? " " + styler.fg("success", `#${t.number}`) : "";
+      return styler.fg("muted", `[${(t.action ?? []).join(",")}]`) + num;
+    }
     case "label":
     case "pull_request": {
       const parts = [];
       if (t.type === "pull_request") parts.push(styler.fg("muted", `[${(t.action ?? []).join(",")}]`));
+      if (t.type === "pull_request" && Number.isInteger(t.number)) parts.push(styler.fg("success", `#${t.number}`));
       for (const x of t.any ?? []) parts.push(styler.fg("success", x));
       for (const x of t.all ?? []) parts.push(styler.fg("success", `+${x}`));
       for (const x of t.none ?? []) parts.push(styler.fg("error", `!${x}`));
@@ -40003,11 +40437,17 @@ function renderTriggerDetail(t, inner, styler, sched = null, staged = null) {
     }
   } else if (t.type === "label" || t.type === "pull_request") {
     if (t.type === "pull_request") out.push(kv("PR actions", (t.action ?? []).join(", ") || "-"));
+    if (t.type === "pull_request" && Number.isInteger(t.number)) out.push(kv("item", `#${t.number}`, "success"));
+    if (t.once === true) out.push(kv("one-shot", t.disarmed ? `spent ${t.disarmed.at ?? "-"}${t.disarmed.jobId ? ` by ${t.disarmed.jobId}` : ""}` : "armed", t.disarmed ? "dim" : "accent"));
     out.push(kv("any of", (t.any ?? []).join(" \xB7 ") || "-", "success"));
     out.push(kv("all of", (t.all ?? []).join(" \xB7 ") || "-", "success"));
     out.push(kv("none of", (t.none ?? []).join(" \xB7 ") || "-", "error"));
   } else if (t.type === "comment") {
     out.push(kv("phrase", `"${t.phrase ?? "-"}"`));
+  } else if (t.type === "issue") {
+    out.push(kv("issue actions", (t.action ?? []).join(", ") || "-"));
+    if (Number.isInteger(t.number)) out.push(kv("item", `#${t.number}`, "success"));
+    if (t.once === true) out.push(kv("one-shot", t.disarmed ? `spent ${t.disarmed.at ?? "-"}${t.disarmed.jobId ? ` by ${t.disarmed.jobId}` : ""}` : "armed", t.disarmed ? "dim" : "accent"));
   }
   blank();
   section("runs");
@@ -40038,6 +40478,12 @@ function renderTriggerDetail(t, inner, styler, sched = null, staged = null) {
     keeps("issue text, file contents, tool output, the agent's own reasoning");
     keeps("replayed into the next job on the same branch; forks never resume");
   }
+  if (t.secrets > 0) {
+    const holds = (text) => out.push(fitLine(styler.fg("border", "\xB7 ") + styler.fg("warning", text), inner, styler));
+    holds(`${t.secrets} vault secret(s) injected${t.secretsProfile ? ` via profile ${t.secretsProfile}` : ""}`);
+    holds("resolved on the host before the container; the job holds no vault credential");
+    holds("the agent can read them, and the forge is on the egress allowlist");
+  }
   if (t.replicas > 1) {
     const races = (text) => out.push(fitLine(styler.fg("border", "\xB7 ") + styler.fg("warning", text), inner, styler));
     races(`each delivery starts ${t.replicas} independent jobs`);
@@ -40065,33 +40511,38 @@ function trustModel(t) {
   }
   const subject = t?.type === "comment" ? "adversarial comment text" : "adversarial issue/PR text";
   const where = `lives in the receiver \xB7 task is ${subject}`;
+  const closeCapable = t?.type === "issue" || t?.type === "pull_request" && (t?.action ?? []).some((a) => a === "closed" || a === "close");
+  const oneShot = (lines) => closeCapable && (t?.once === true || t?.disarmed) ? [...lines, "one-shot: the WORKER writes on.disarmed into triggers.json, strictly after the run record \u2014 spent always has its run"] : lines;
   switch (t?.forge) {
     case "gitlab":
-      return [
+      return oneShot([
         "authorized by the actor's resolved project access level (>= Developer) \u2014 a label is NOT approval here",
         "HMAC over the body (19.0+) or a bare X-Gitlab-Token \xB7 dedup by webhook-id",
         where
-      ];
+      ]);
     case "forgejo":
-      return [
+      return oneShot([
         "authorized by the actor's resolved repository permission (admin|write), on every trigger type",
         "HMAC over the body (GitHub-compatible) \xB7 dedup by X-GitHub-Delivery GUID",
         where
-      ];
+      ]);
     case "azure":
-      return [
+      return oneShot([
         "authorized by the actor's resolved project membership \u2014 work items name the actor only by email",
         "NO HMAC: a shared secret that covers no bytes \xB7 dedup by the payload's own id (OQ-015)",
         where
-      ];
+      ]);
     default:
-      return [
+      return oneShot([
         // A review trigger reads the REVIEWER's author_association, not the PR author's (issue #66), so it
         // cannot share the generic line: an operator reading "author gate" would picture the wrong person.
-        t?.type === "comment" ? "authorized by a collaborator comment (author_association) + HMAC" : t?.type === "pull_request" && (t?.action ?? []).includes("review_submitted") ? "authorized by the REVIEWER's author_association (not the PR author's) + HMAC" : "authorized by a collaborator's label + HMAC webhook + author gate",
+        // A close rule reads the CLOSER's resolved permission (issue #231), for the inversion's sharper
+        // sibling: GitHub sends NO association for a close at all, so the collaborator-label line would
+        // name a gate this rule never runs — and a wrong trust model is worse than an absent one.
+        closeCapable ? "authorized by the CLOSER's resolved repository permission (admin|write) + HMAC \u2014 a close names no author_association" : t?.type === "comment" ? "authorized by a collaborator comment (author_association) + HMAC" : t?.type === "pull_request" && (t?.action ?? []).includes("review_submitted") ? "authorized by the REVIEWER's author_association (not the PR author's) + HMAC" : "authorized by a collaborator's label + HMAC webhook + author gate",
         "dedup by X-GitHub-Delivery GUID (redelivery-safe)",
         where
-      ];
+      ]);
   }
 }
 function triggerDetailHints(inner, styler, pendingDelete = false) {
@@ -40332,7 +40783,7 @@ var init_dashboard = __esm({
     TAIL_VIEWPORT = 20;
     MIN_WIDTH2 = 8;
     DRILL_WIDTH = 70;
-    KIND_COLOR = { cron: "accent", label: "syntaxType", comment: "syntaxKeyword", pull_request: "syntaxFunction" };
+    KIND_COLOR = { cron: "accent", label: "syntaxType", comment: "syntaxKeyword", pull_request: "syntaxFunction", issue: "syntaxString" };
     KIND_WIDTH = 13;
     FRAME_CHROME_ROWS = 4;
   }
@@ -40357,7 +40808,7 @@ __export(setup_wizard_exports, {
   runSetupWizard: () => runSetupWizard,
   runtimeDirFor: () => runtimeDirFor
 });
-import * as nodeFs4 from "node:fs";
+import * as nodeFs5 from "node:fs";
 import { execFileSync as execFileSync3, spawn as nodeSpawn2 } from "node:child_process";
 import { homedir as homedir2 } from "node:os";
 import { join as join6 } from "node:path";
@@ -40373,7 +40824,7 @@ async function defaultProbeQueue(url) {
 async function detectDeployment({
   env = process.env,
   cwd = process.cwd(),
-  fs = nodeFs4,
+  fs = nodeFs5,
   probeQueue = defaultProbeQueue
 } = {}) {
   const pointerRes = readPointer({ path: pointerPath(env), fs });
@@ -40500,7 +40951,7 @@ async function ensureDocker(ui, notify, { platform, probeDockerFn }) {
 function npmSpawnOptions(platform, dir) {
   return platform === "win32" ? { bin: "npm.cmd", options: { cwd: dir, shell: true } } : { bin: "npm", options: { cwd: dir } };
 }
-function listRepoSkills(cwd, fs = nodeFs4) {
+function listRepoSkills(cwd, fs = nodeFs5) {
   try {
     const root = join6(cwd, ".pi", "skills");
     return fs.readdirSync(root).filter((name) => SKILL_NAME_RE.test(name) && fs.existsSync(join6(root, name, "SKILL.md")));
@@ -40528,7 +40979,7 @@ function ensureDeploymentPackageJson(fs, dir) {
 }
 async function runSetupWizard(paths, ctx, notify, deps = {}) {
   const {
-    fs = nodeFs4,
+    fs = nodeFs5,
     env = process.env,
     platform = process.platform,
     execPath = process.execPath,
@@ -40842,7 +41293,7 @@ async function offerFirstTrigger(repoCwd, deployDir, ui, notify, { fs, listRepoS
   );
 }
 function registerNudge(pi, deps = {}) {
-  const { fs = nodeFs4, env = process.env, homedirFn = homedir2 } = deps;
+  const { fs = nodeFs5, env = process.env, homedirFn = homedir2 } = deps;
   pi.on("session_start", (event, ctx) => {
     try {
       if (event?.reason !== "startup" || !ctx?.hasUI) return;
@@ -40867,8 +41318,8 @@ var init_setup_wizard = __esm({
     init_deployment_pointer();
     init_read_model();
     init_index();
-    RUNTIME_VERSION = "1.2.0";
-    RECEIVER_VERSION = "1.1.0";
+    RUNTIME_VERSION = "1.4.0";
+    RECEIVER_VERSION = "1.3.0";
     RUNTIME_PKG = "@edgehero/pi-dispatch";
     RECEIVER_PKG = "@edgehero/pi-dispatch-receiver";
     NUDGE_MARKER_BASENAME = "pi-dispatch-setup.nudged";
@@ -40883,10 +41334,108 @@ var init_setup_wizard = __esm({
   }
 });
 
+// src/secrets-command.ts
+var secrets_command_exports = {};
+__export(secrets_command_exports, {
+  runSecretsCommand: () => runSecretsCommand
+});
+function renderProfiles(profiles) {
+  const names = Object.keys(profiles).sort();
+  if (names.length === 0) return "No resolver profiles are declared in the settings overlay.";
+  return ["Resolver profiles (settings overlay):", ...names.map((n) => `  ${n} -> ${profiles[n]}`)].join("\n");
+}
+async function runSecretsCommand(paths, ctx, notify, tokens, deps = {}) {
+  const ui = ctx?.ui;
+  const fsSeam = deps.fs ? { fs: deps.fs } : {};
+  const view = readSettingsView({ settingsFile: paths.settingsFile, ...fsSeam });
+  if (view.invalid) {
+    notify?.(`settings overlay is unreadable (${view.invalid}) \u2014 fix it before declaring a profile`, "error");
+    return;
+  }
+  const profiles = { ...view.overlay?.secretProfiles ?? {} };
+  const action = tokens[0] ?? "list";
+  if (action === "list") {
+    notify?.(renderProfiles(profiles), "info");
+    return;
+  }
+  if (typeof ui?.input !== "function" || typeof ui?.confirm !== "function") {
+    notify?.("declaring a profile needs dialogs (newer pi) \u2014 no input/confirm available", "warning");
+    return;
+  }
+  if (action === "add") {
+    const nameAnswer = await ui.input("profile name \u2014 what a trigger's run.secretsProfile will say (e.g. prod)", "default");
+    const name = (nameAnswer ?? "").trim();
+    if (name === "") return;
+    if (!PROFILE_NAME.test(name)) {
+      notify?.("a profile name may use letters, digits, dot, dash and underscore only \u2014 PI_SECRET_PROFILES is a comma-separated list of name:path pairs", "error");
+      return;
+    }
+    const pathAnswer = await ui.input("resolver \u2014 ABSOLUTE path to the script that reads one reference", "/opt/pi/resolve.sh");
+    const path = (pathAnswer ?? "").trim();
+    if (path === "") return;
+    if (!(path.startsWith("/") || /^([A-Za-z]:[\\/]|\\\\)/.test(path))) {
+      notify?.("the resolver needs an ABSOLUTE path: a service manager's working directory is not your shell's", "error");
+      return;
+    }
+    const replacing = profiles[name] ? `
+
+This REPLACES the current ${name} -> ${profiles[name]}` : "";
+    const ok = await ui.confirm(
+      "Declare a secret resolver",
+      `${paths.settingsFile} gets:
+${JSON.stringify({ secretProfiles: { ...profiles, [name]: path } }, null, 2)}${replacing}
+
+The worker EXECUTES this script, as the account it runs as, once per reference. It must also sit inside PI_SECRET_RESOLVER_ROOTS or the worker will refuse it.`
+    );
+    if (!ok) {
+      notify?.("not declared", "info");
+      return;
+    }
+    const res = writeSettings({ settingsFile: paths.settingsFile, mutate: (o) => ({ ...o, secretProfiles: { ...profiles, [name]: path } }), ...fsSeam });
+    if (res.invalid) {
+      notify?.(`rejected: ${res.invalid}`, "error");
+      return;
+    }
+    notify?.(`declared ${name} -> ${path}. A trigger reaches it with "secretsProfile": "${name}" beside its "secrets" map, which is an edit to triggers.json.`, "info");
+    return;
+  }
+  if (action === "remove") {
+    const name = (tokens[1] ?? "").trim();
+    if (!name || !(name in profiles)) {
+      notify?.(`no such profile. ${renderProfiles(profiles)}`, "warning");
+      return;
+    }
+    const ok = await ui.confirm("Remove a secret resolver", `${name} -> ${profiles[name]}
+
+Every trigger naming it refuses PRE-SPEND after this, rather than running without its secrets.`);
+    if (!ok) {
+      notify?.("not removed", "info");
+      return;
+    }
+    const next = { ...profiles };
+    delete next[name];
+    const res = writeSettings({ settingsFile: paths.settingsFile, mutate: (o) => ({ ...o, secretProfiles: next }), ...fsSeam });
+    if (res.invalid) {
+      notify?.(`rejected: ${res.invalid}`, "error");
+      return;
+    }
+    notify?.(`removed ${name}`, "info");
+    return;
+  }
+  notify?.("usage: /dispatch secrets <list|add|remove <name>>", "warning");
+}
+var PROFILE_NAME;
+var init_secrets_command = __esm({
+  "src/secrets-command.ts"() {
+    init_read_model();
+    PROFILE_NAME = /^[A-Za-z0-9._-]+$/;
+  }
+});
+
 // src/index.ts
 import { VERSION } from "@earendil-works/pi-coding-agent";
 import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
-import * as nodeFs5 from "node:fs";
+import * as nodeFs6 from "node:fs";
 function computePiVersionAdvisory(version, supported) {
   if (version === supported || version === "0.0.0") return void 0;
   return `pi-dispatch admin: running on pi ${version}, tested with pi ${supported} \u2014 things should work; report anything odd, and check for a newer @edgehero/pi-dispatch-admin`;
@@ -41028,7 +41577,7 @@ function registerTools(pi) {
   pi.registerTool({
     name: "dispatch_triggers",
     label: "pi-dispatch triggers",
-    description: "Read-only. Lists the configured triggers as `{ index, ...trigger }` entries. Use the `index` to target a specific trigger with dispatch_trigger_edit or dispatch_trigger_delete.",
+    description: "Read-only. Lists the configured triggers as `{ index, ...trigger }` entries. Use the `index` to target a specific trigger with dispatch_trigger_edit or dispatch_trigger_delete. A close-capable entry (kind issue, or a pull_request on the forge's close word) may carry `on.number` (narrowed to one item), `on.once` (a one-shot), and `on.disarmed` { at, jobId? } \u2014 the worker's mark that the one-shot fired; a disarmed entry still lists here but matches nothing until an operator deletes the key to re-arm it.",
     parameters: typebox_exports.Object({}),
     async execute() {
       const paths = resolvePaths(process.env);
@@ -41073,7 +41622,7 @@ function registerTools(pi) {
   pi.registerTool({
     name: "dispatch_trigger_add",
     label: "pi-dispatch add trigger",
-    description: "Adds a trigger to triggers.json and applies it live. The operator MUST approve a confirm dialog showing the entry; with no interactive operator it is refused. `flow` is the .pi/skills/<name> skill the job runs (its SKILL.md is the agent's instructions). `kind` = cron|label|comment|pull_request. cron (local) needs id, pattern, `folder` (absolute host path the job runs in), `flow`, and `task` (the prompt text handed to the agent), and may set optional model/provider/maxTurns for that schedule (omit = deployment default). label needs labels[]+flow; comment needs phrase+flow; pull_request needs action[] (+ optional labels[]) + flow. Webhook triggers take an optional `forge` = github (default) | gitlab | forgejo | azure, which also decides which action words pull_request accepts: github is labeled|opened|synchronize|reopened|review_submitted, gitlab is open|update|reopen|approved, forgejo is label_updated|opened|synchronized|reopened, azure is created|updated. An azure label or comment trigger must also set `repository` (a work item belongs to a project, not a repository), and an azure pull_request trigger may not carry labels[] at all. A github review_submitted trigger may also set reviewState[] (approved|changes_requested|commented) to narrow which verdicts fire; omitted, all three do. For webhook triggers the repo and the task come from the triggering issue/PR event \u2014 set only the match + flow \u2014 and they run under the deployment default model.",
+    description: "Adds a trigger to triggers.json and applies it live. The operator MUST approve a confirm dialog showing the entry; with no interactive operator it is refused. `flow` is the .pi/skills/<name> skill the job runs (its SKILL.md is the agent's instructions). `kind` = cron|label|comment|pull_request|issue. cron (local) needs id, pattern, `folder` (absolute host path the job runs in), `flow`, and `task` (the prompt text handed to the agent), and may set optional model/provider/maxTurns for that schedule (omit = deployment default). label needs labels[]+flow; comment needs phrase+flow; pull_request needs action[] (+ optional labels[]) + flow. issue fires when an ISSUE closes: it needs flow, its action[] defaults to the forge's close word (github/forgejo closed, gitlab close; azure has no close trigger), and it may set `number` (the forge's own item number, narrowing the rule to that one issue) and `once: true` (a one-shot: it fires once, the run is recorded, then the worker disarms the entry by writing on.disarmed; once requires number). A close-only pull_request rule accepts the same number/once narrowing. Webhook triggers take an optional `forge` = github (default) | gitlab | forgejo | azure, which also decides which action words pull_request accepts: github is labeled|opened|synchronize|reopened|review_submitted|closed, gitlab is open|update|reopen|approved|close, forgejo is label_updated|opened|synchronized|reopened|closed, azure is created|updated (no close word). The close word rides alone: it cannot be mixed with other actions in one entry. An azure label or comment trigger must also set `repository` (a work item belongs to a project, not a repository), and an azure pull_request trigger may not carry labels[] at all. A github review_submitted trigger may also set reviewState[] (approved|changes_requested|commented) to narrow which verdicts fire; omitted, all three do. For webhook triggers the repo and the task come from the triggering issue/PR event \u2014 set only the match + flow \u2014 and they run under the deployment default model.",
     executionMode: "sequential",
     parameters: typebox_exports.Object({
       kind: typebox_exports.String(),
@@ -41090,13 +41639,18 @@ function registerTools(pi) {
       phrase: typebox_exports.Optional(typebox_exports.String()),
       labels: typebox_exports.Optional(typebox_exports.Array(typebox_exports.String())),
       action: typebox_exports.Optional(typebox_exports.Array(typebox_exports.String())),
+      // The close-trigger narrowings (issue #231), read only by the close-capable arms of
+      // buildTriggerEntry and refused fail-loud by the shared validator everywhere else -- the
+      // `repository` posture above, restated for the two fields whose whole point is narrowing spend.
+      number: typebox_exports.Optional(typebox_exports.Integer({ minimum: 1 })),
+      once: typebox_exports.Optional(typebox_exports.Boolean()),
       model: typebox_exports.Optional(typebox_exports.String()),
       provider: typebox_exports.Optional(typebox_exports.String()),
       maxTurns: typebox_exports.Optional(typebox_exports.Integer({ minimum: 1 }))
     }),
     async execute(_id, params, _signal, _onUpdate, ctx) {
       const entry = buildTriggerEntry(params.kind, params);
-      if (!entry) throw new Error(`unknown trigger kind '${params.kind}' (cron|label|comment|pull_request)`);
+      if (!entry) throw new Error(`unknown trigger kind '${params.kind}' (cron|label|comment|pull_request|issue)`);
       const result = await confirmedWrite(
         ctx,
         { title: `Add ${params.kind} trigger`, message: `Add to triggers.json:
@@ -41307,6 +41861,17 @@ function buildTriggerEntry(kind, f) {
     const on = { type: "pull_request", action: asWords(f.action) };
     const any = asWords(f.labels ?? f.any);
     if (any.length > 0) on.any = any;
+    const prNumber = optInt(f.number);
+    if (prNumber !== void 0) on.number = prNumber;
+    if (typeof f.once === "boolean") on.once = f.once;
+    return { on, run: { kind: forge, flow: f.flow } };
+  }
+  if (kind === "issue") {
+    const action = asWords(f.action);
+    const on = { type: "issue", action: action.length > 0 ? action : [ISSUE_CLOSE_WORD[forge] ?? "closed"] };
+    const number = optInt(f.number);
+    if (number !== void 0) on.number = number;
+    if (typeof f.once === "boolean") on.once = f.once;
     return { on, run: { kind: forge, flow: f.flow } };
   }
   return null;
@@ -41358,7 +41923,7 @@ async function dispatch(pi, args, ctx) {
     if (det.state === "pointer" && !runtimeSkewNoticed) {
       const ptrRes = readPointer({ path: pointerPath(process.env) });
       const deploymentDir = ptrRes.pointer?.deploymentDir;
-      const installed = deploymentDir ? readInstalledVersion2(nodeFs5, runtimeDirFor2(deploymentDir)) : void 0;
+      const installed = deploymentDir ? readInstalledVersion2(nodeFs6, runtimeDirFor2(deploymentDir)) : void 0;
       if (typeof installed === "string" && installed !== RUNTIME_VERSION2) {
         runtimeSkewNoticed = true;
         notify?.(
@@ -41458,6 +42023,11 @@ ${renderBudget({ budget, settings: settings2 })}`);
       applyUnset(paths.settingsFile, tokens, notify);
       return;
     }
+    case "secrets": {
+      const { runSecretsCommand: runSecretsCommand2 } = await Promise.resolve().then(() => (init_secrets_command(), secrets_command_exports));
+      await runSecretsCommand2(paths, ctx, notify, tokens.slice(1));
+      return;
+    }
     case "setup": {
       const { runSetupWizard: runSetupWizard2 } = await Promise.resolve().then(() => (init_setup_wizard(), setup_wizard_exports));
       await runSetupWizard2(paths, ctx, notify, { openDashboardFn: openDashboard });
@@ -41512,7 +42082,7 @@ async function assembleGraph(paths) {
   });
 }
 function realArtifactDeps() {
-  return { fs: nodeFs5, openBrowser, env: process.env, now: () => Date.now(), platform: process.platform };
+  return { fs: nodeFs6, openBrowser, env: process.env, now: () => Date.now(), platform: process.platform };
 }
 function isHeadlessEnv(env, platform) {
   if (env?.SSH_CONNECTION || env?.SSH_TTY) return "SSH session";
@@ -42038,7 +42608,7 @@ function completeArguments(prefix) {
   }
   return null;
 }
-var USED_API, SUPPORTED_PI_VERSION, piVersionAdvisory, piVersionCheckDone, runtimeSkewNoticed, CHANNEL, REBUILT_NOTICE, USAGE, KNOWN_SUBCOMMANDS, FORGE_PROMPT, PR_ACTION_VOCAB, PRICING, INSIGHTS_USAGE, VIEWPORT_LINES;
+var USED_API, SUPPORTED_PI_VERSION, piVersionAdvisory, piVersionCheckDone, runtimeSkewNoticed, CHANNEL, REBUILT_NOTICE, USAGE, KNOWN_SUBCOMMANDS, FORGE_PROMPT, ISSUE_CLOSE_WORD, PR_ACTION_VOCAB, PRICING, INSIGHTS_USAGE, VIEWPORT_LINES;
 var init_index = __esm({
   "src/index.ts"() {
     init_build();
@@ -42063,7 +42633,7 @@ var init_index = __esm({
     runtimeSkewNoticed = false;
     CHANNEL = "pi-dispatch-admin";
     REBUILT_NOTICE = (reason) => `replaced invalid settings file (${reason}) \u2014 other keys were lost`;
-    USAGE = "usage: /dispatch <status|pause|resume|run|runs|logs|budget|insights|triggers|settings|set|unset|setup>";
+    USAGE = "usage: /dispatch <status|pause|resume|run|runs|logs|budget|insights|triggers|settings|set|unset|setup|secrets>";
     KNOWN_SUBCOMMANDS = [
       "status",
       "pause",
@@ -42077,13 +42647,18 @@ var init_index = __esm({
       "settings",
       "set",
       "unset",
-      "setup"
+      "setup",
+      "secrets"
     ];
     FORGE_PROMPT = "forge \u2014 github, gitlab, forgejo or azure";
+    ISSUE_CLOSE_WORD = { github: "closed", gitlab: "close", forgejo: "closed" };
     PR_ACTION_VOCAB = {
-      github: { hint: "labeled opened synchronize reopened review_submitted", dflt: "labeled" },
-      gitlab: { hint: "open update reopen approved", dflt: "update" },
-      forgejo: { hint: "label_updated opened synchronized reopened", dflt: "label_updated" },
+      // The close words ride the hint too (issue #231): the dialog passes whatever is typed through the
+      // shared validator, so a close-only rule IS authorable here, and a hint that omits the word reads
+      // as the word not existing. The loader refuses a list mixing a close word with any other action.
+      github: { hint: "labeled opened synchronize reopened review_submitted closed", dflt: "labeled" },
+      gitlab: { hint: "open update reopen approved close", dflt: "update" },
+      forgejo: { hint: "label_updated opened synchronized reopened closed", dflt: "label_updated" },
       azure: { hint: "created updated", dflt: "updated" }
     };
     PRICING = { listPricedModels, getPricedModel, isZeroRated, reprice, piAiVersion };