@wrongstack/core 0.289.0 → 0.291.1

package/dist/execution/index.js

@@ -32,8 +32,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat3 = await fs.stat(targetPath);
-      mode = stat3.mode & 511;
+      const stat4 = await fs.stat(targetPath);
+      mode = stat4.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -76,7 +76,7 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve4) => setTimeout(resolve4, delays[i]));
+      await new Promise((resolve6) => setTimeout(resolve6, delays[i]));
     }
   }
   throw lastErr;
@@ -181,10 +181,10 @@ function validateAgainstSchema(value, schema) {
   return { ok: errors.length === 0, errors };
 }
 var MAX_SCHEMA_DEPTH = 64;
-function walk(value, schema, path11, errors, depth) {
+function walk(value, schema, path12, errors, depth) {
   if (depth > MAX_SCHEMA_DEPTH) {
     errors.push({
-      path: path11 || "<root>",
+      path: path12 || "<root>",
       message: `schema nesting exceeds maximum depth (${MAX_SCHEMA_DEPTH})`
     });
     return;
@@ -192,7 +192,7 @@ function walk(value, schema, path11, errors, depth) {
   if (schema.enum !== void 0) {
     if (!enumIncludes(schema.enum, value)) {
       errors.push({
-        path: path11 || "<root>",
+        path: path12 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -201,7 +201,7 @@ function walk(value, schema, path11, errors, depth) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path11 || "<root>",
+        path: path12 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)} (${previewValue(value)})`
       });
       return;
@@ -213,7 +213,7 @@ function walk(value, schema, path11, errors, depth) {
       if (!(req in obj)) {
         const expected = schema.properties?.[req]?.type;
         errors.push({
-          path: joinPath(path11, req),
+          path: joinPath(path12, req),
           message: `required property missing${typeof expected === "string" ? ` (expected ${expected})` : ""}`
         });
       }
@@ -221,14 +221,14 @@ function walk(value, schema, path11, errors, depth) {
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk(obj[key], subSchema, joinPath(path11, key), errors, depth + 1);
+          walk(obj[key], subSchema, joinPath(path12, key), errors, depth + 1);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
     for (let i = 0; i < value.length; i++) {
-      walk(value[i], schema.items, `${path11}[${i}]`, errors, depth + 1);
+      walk(value[i], schema.items, `${path12}[${i}]`, errors, depth + 1);
     }
   }
 }
@@ -445,9 +445,23 @@ function mapContent(msg, fn) {
   }
   return { ...msg, content: next };
 }
+function hasMeaningfulContent(content) {
+  if (typeof content === "string") return content.trim().length > 0;
+  for (const block of content) {
+    if (block.type === "text") {
+      if (block.text.trim().length > 0) return true;
+      continue;
+    }
+    if (block.type === "thinking") {
+      if (block.thinking.trim().length > 0 || block.signature) return true;
+      continue;
+    }
+    return true;
+  }
+  return false;
+}
 function isEmptyMessage(msg) {
-  if (typeof msg.content === "string") return msg.content.trim().length === 0;
-  return msg.content.length === 0;
+  return !hasMeaningfulContent(msg.content);
 }
 
 // src/utils/regex-guard.ts
@@ -488,7 +502,7 @@ function compileUserRegex(pattern, flags) {
 
 // src/utils/safe-json.ts
 function safeParse(input, maxBytes = 5e6) {
-  if (input.length > maxBytes) {
+  if (Buffer.byteLength(input, "utf8") > maxBytes) {
     return { ok: false, error: `Input exceeds limit (${maxBytes} bytes)` };
   }
   try {
@@ -501,84 +515,21 @@ function safeParse(input, maxBytes = 5e6) {
   }
 }
 
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
+}
+
 // src/utils/slug.ts
 function slugify(name, fallback = "prompt", maxLen = 64) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxLen).replace(/-+$/g, "") || fallback;
 }
 
-// src/utils/ulid.ts
-import { randomBytes as randomBytes2 } from "node:crypto";
-var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-var ENCODING_LEN = ENCODING.length;
-var TIME_LEN = 10;
-var RANDOM_LEN = 16;
-function encodeTime(now, len) {
-  let mod;
-  let str = "";
-  for (let i = len - 1; i >= 0; i--) {
-    mod = now % ENCODING_LEN;
-    str = ENCODING[mod] + str;
-    now = (now - mod) / ENCODING_LEN;
-  }
-  return str;
-}
-function encodeRandom(len) {
-  const bytes = randomBytes2(len);
-  let str = "";
-  for (let i = 0; i < len; i++) {
-    str += ENCODING[bytes[i] % ENCODING_LEN];
-  }
-  return str;
-}
-function ulid(seedTime = Date.now()) {
-  return encodeTime(seedTime, TIME_LEN) + encodeRandom(RANDOM_LEN);
-}
-
-// src/utils/sleep.ts
-function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
-}
-
 // src/utils/string.ts
 function truncate(s, max) {
   return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
 }
 
-// src/utils/tool-subject.ts
-var GLOB_METACHARACTERS = /[*?[\]]/g;
-function escapeGlobSubject(value) {
-  return value.replace(GLOB_METACHARACTERS, (char) => `\\${char}`);
-}
-function normalizePathSubject(value) {
-  return escapeGlobSubject(value.replace(/\\/g, "/"));
-}
-function isPathSubjectKey(subjectKey) {
-  return subjectKey === "path" || subjectKey === "file" || subjectKey === "files";
-}
-function subjectForToolInput(toolName, input, subjectKey) {
-  if (!input || typeof input !== "object") return void 0;
-  const obj = input;
-  if (subjectKey) {
-    const value = obj[subjectKey];
-    if (typeof value === "string") {
-      return isPathSubjectKey(subjectKey) ? normalizePathSubject(value) : escapeGlobSubject(value);
-    }
-  }
-  if (toolName === "bash" && typeof obj.command === "string") {
-    return escapeGlobSubject(obj.command);
-  }
-  if (typeof obj.path === "string") {
-    return normalizePathSubject(obj.path);
-  }
-  if (typeof obj.url === "string") {
-    return escapeGlobSubject(obj.url);
-  }
-  if (typeof obj.name === "string") {
-    return escapeGlobSubject(obj.name);
-  }
-  return void 0;
-}
-
 // src/utils/tool-wire-compact.ts
 var TOOL_DESCRIPTION_MAX_CHARS = 400;
 var SCHEMA_DESCRIPTION_MAX_CHARS = 120;
@@ -595,9 +546,11 @@ function compactToolDefinitionForWire(tool, opts = {}) {
       tool.description ?? "",
       opts.descriptionMaxChars ?? TOOL_DESCRIPTION_MAX_CHARS
     ),
-    inputSchema: compactSchemaDescriptions(
-      tool.inputSchema,
-      opts.schemaDescriptionMaxChars ?? SCHEMA_DESCRIPTION_MAX_CHARS
+    inputSchema: normalizeTopLevelToolSchema(
+      compactSchemaDescriptions(
+        tool.inputSchema,
+        opts.schemaDescriptionMaxChars ?? SCHEMA_DESCRIPTION_MAX_CHARS
+      )
     )
   };
   if (useDefaultOptions && typeof tool === "object" && tool !== null) {
@@ -605,6 +558,44 @@ function compactToolDefinitionForWire(tool, opts = {}) {
   }
   return compact;
 }
+function normalizeTopLevelToolSchema(schema) {
+  const combinators = ["oneOf", "anyOf", "allOf"].map((keyword) => ({ keyword, branches: schema[keyword] })).filter(
+    (entry) => Array.isArray(entry.branches)
+  );
+  if (combinators.length === 0) return schema;
+  const out = { ...schema, type: "object" };
+  delete out["oneOf"];
+  delete out["anyOf"];
+  delete out["allOf"];
+  const properties = isRecord(schema["properties"]) ? { ...schema["properties"] } : {};
+  let required = stringSet(schema["required"]);
+  for (const { keyword, branches } of combinators) {
+    const objectBranches = branches.filter(isRecord);
+    for (const branch of objectBranches) {
+      if (isRecord(branch["properties"])) Object.assign(properties, branch["properties"]);
+    }
+    const branchRequired = objectBranches.map((branch) => stringSet(branch["required"]));
+    if (keyword === "allOf") {
+      for (const fields of branchRequired) for (const field of fields) required.add(field);
+    } else if (branchRequired.length > 0) {
+      const common = new Set(
+        [...branchRequired[0]].filter(
+          (field) => branchRequired.slice(1).every((fields) => fields.has(field))
+        )
+      );
+      required = /* @__PURE__ */ new Set([...required, ...common]);
+    }
+  }
+  out["properties"] = properties;
+  if (required.size > 0) out["required"] = [...required];
+  else delete out["required"];
+  return out;
+}
+function stringSet(value) {
+  return new Set(
+    Array.isArray(value) ? value.filter((item) => typeof item === "string") : []
+  );
+}
 function compactSchemaDescriptions(schema, maxDescriptionChars = SCHEMA_DESCRIPTION_MAX_CHARS) {
   const compact = compactSchemaNode(schema, maxDescriptionChars);
   return isRecord(compact) ? compact : { type: "object", properties: {} };
@@ -1499,6 +1490,69 @@ function resolveToolResultRenderMode(modes, toolName) {
   return normalizeToolResultRenderMode(modes?.[toolName]) ?? DEFAULT_TOOL_RESULT_RENDER_MODE;
 }
 
+// src/utils/tool-subject.ts
+var GLOB_METACHARACTERS = /[*?[\]]/g;
+function escapeGlobSubject(value) {
+  return value.replace(GLOB_METACHARACTERS, (char) => `\\${char}`);
+}
+function normalizePathSubject(value) {
+  return escapeGlobSubject(value.replace(/\\/g, "/"));
+}
+function isPathSubjectKey(subjectKey) {
+  return subjectKey === "path" || subjectKey === "file" || subjectKey === "files";
+}
+function subjectForToolInput(toolName, input, subjectKey) {
+  if (!input || typeof input !== "object") return void 0;
+  const obj = input;
+  if (subjectKey) {
+    const value = obj[subjectKey];
+    if (typeof value === "string") {
+      return isPathSubjectKey(subjectKey) ? normalizePathSubject(value) : escapeGlobSubject(value);
+    }
+  }
+  if (toolName === "bash" && typeof obj.command === "string") {
+    return escapeGlobSubject(obj.command);
+  }
+  if (typeof obj.path === "string") {
+    return normalizePathSubject(obj.path);
+  }
+  if (typeof obj.url === "string") {
+    return escapeGlobSubject(obj.url);
+  }
+  if (typeof obj.name === "string") {
+    return escapeGlobSubject(obj.name);
+  }
+  return void 0;
+}
+
+// src/utils/ulid.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var ENCODING_LEN = ENCODING.length;
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
+function encodeTime(now, len) {
+  let mod;
+  let str = "";
+  for (let i = len - 1; i >= 0; i--) {
+    mod = now % ENCODING_LEN;
+    str = ENCODING[mod] + str;
+    now = (now - mod) / ENCODING_LEN;
+  }
+  return str;
+}
+function encodeRandom(len) {
+  const bytes = randomBytes2(len);
+  let str = "";
+  for (let i = 0; i < len; i++) {
+    str += ENCODING[bytes[i] % ENCODING_LEN];
+  }
+  return str;
+}
+function ulid(seedTime = Date.now()) {
+  return encodeTime(seedTime, TIME_LEN) + encodeRandom(RANDOM_LEN);
+}
+
 // src/utils/wstack-paths.ts
 import { createHash } from "node:crypto";
 import * as fs2 from "node:fs";
@@ -1551,6 +1605,27 @@ function resolveWstackPaths(opts) {
     homeDir,
     configDir: globalRoot,
     globalConfig: path2.join(globalRoot, "config.json"),
+    profilesDir: path2.join(globalRoot, "profiles"),
+    profileConfig: (name) => {
+      const safe = name.replace(/[/\\:]/g, "_").replace(/\.\./g, "_");
+      return path2.join(globalRoot, "profiles", safe || "default", "config.json");
+    },
+    profileStatuslineConfig: (name) => {
+      const safe = name.replace(/[/\\:]/g, "_").replace(/\.\./g, "_");
+      return path2.join(globalRoot, "profiles", safe || "default", "statusline.json");
+    },
+    profileModeConfig: (name) => {
+      const safe = name.replace(/[/\\:]/g, "_").replace(/\.\./g, "_");
+      return path2.join(globalRoot, "profiles", safe || "default", "mode.json");
+    },
+    profileProviderStatus: (name) => {
+      const safe = name.replace(/[/\\:]/g, "_").replace(/\.\./g, "_");
+      return path2.join(globalRoot, "profiles", safe || "default", "provider-status.json");
+    },
+    profileUpdateCache: (name) => {
+      const safe = name.replace(/[/\\:]/g, "_").replace(/\.\./g, "_");
+      return path2.join(globalRoot, "profiles", safe || "default", "update-cache.json");
+    },
     secretsKey: path2.join(globalRoot, ".key"),
     globalMemory: path2.join(globalRoot, "memory.md"),
     globalSkills: path2.join(globalRoot, "skills"),
@@ -1590,6 +1665,7 @@ function resolveWstackPaths(opts) {
     projectAutophase: path2.join(projectDir, "autophase"),
     projectSddBoards: path2.join(projectDir, "sdd-boards"),
     syncConfig: path2.join(globalRoot, "sync.json"),
+    configHistoryDir: path2.join(globalRoot, "config-history"),
     projectStatus: (projectHash2) => path2.join(globalRoot, "projects", projectHash2, "status.json")
   };
 }
@@ -2559,18 +2635,20 @@ function isTextBlock(b) {
 // src/types/provider.ts
 var CONTEXT_OVERFLOW_RE = /context.length|context.window|max.*tokens?.*exceeded|prompt is too long|too long|exceeds the context|\btokens\b.*exceed|context_length_exceeded/i;
 var CONTENT_FILTER_RE = /content.(filter|policy|moderation)|safety (system|filter)/i;
+var QUOTA_EXHAUSTED_RE = /(?:insufficient|exhausted|depleted|exceeded|no|not enough)[-_\s]*(?:quota|credit|balance)|(?:quota|credit|balance)[-_\s]*(?:exhausted|depleted|exceeded|insufficient)|billing[_\s-]*(?:hard[_\s-]*)?limit|payment required|spending limit|plan limit/i;
 function classifyProviderError(status, body, message) {
   const type = body?.type;
+  const text = [message, body?.message, type, body?.raw].filter(Boolean).join("\n");
   if (status === 0) return "network";
   if (status === 408) return "timeout";
   if (status === 599) return "stream_hang";
+  if (status === 402 || QUOTA_EXHAUSTED_RE.test(text)) return "quota_exhausted";
   if (type === "rate_limit_error" || status === 429) return "rate_limit";
   if (type === "overloaded_error" || status === 529) return "overloaded";
   if (status >= 500) return "server";
   if (type === "authentication_error" || type === "permission_error" || status === 401 || status === 403) {
     return "auth";
   }
-  const text = [message, body?.message, type, body?.raw].filter(Boolean).join("\n");
   if (type === "content_filter" || CONTENT_FILTER_RE.test(text)) return "content_filter";
   if (status === 413 || status >= 400 && CONTEXT_OVERFLOW_RE.test(text)) {
     return "context_overflow";
@@ -2583,6 +2661,7 @@ function isRetryableKind(kind) {
 }
 var RETRYABLE_BY_KIND = {
   rate_limit: true,
+  quota_exhausted: false,
   overloaded: true,
   server: true,
   timeout: true,
@@ -2599,6 +2678,7 @@ function isFallbackWorthy(kind) {
 }
 var FALLBACK_WORTHY_BY_KIND = {
   rate_limit: true,
+  quota_exhausted: true,
   overloaded: true,
   server: true,
   timeout: true,
@@ -2677,6 +2757,7 @@ var KIND_TO_CODE = {
   network: ERROR_CODES.PROVIDER_NETWORK_ERROR,
   timeout: ERROR_CODES.PROVIDER_NETWORK_ERROR,
   rate_limit: ERROR_CODES.PROVIDER_RATE_LIMITED,
+  quota_exhausted: ERROR_CODES.PROVIDER_RATE_LIMITED,
   auth: ERROR_CODES.PROVIDER_AUTH_FAILED,
   overloaded: ERROR_CODES.PROVIDER_OVERLOADED,
   context_overflow: ERROR_CODES.PROVIDER_CONTEXT_OVERFLOW,
@@ -2690,6 +2771,84 @@ function kindToCode(kind) {
   return KIND_TO_CODE[kind];
 }
 
+// src/core/model-availability-calendar.ts
+function logicalCalendarTarget(providerId, model) {
+  if (providerId !== "omniroute") return { providerId, model };
+  const slash = model.indexOf("/");
+  return slash > 0 && slash < model.length - 1 ? { providerId: model.slice(0, slash), model: model.slice(slash + 1) } : { providerId, model };
+}
+var WEEKDAYS = {
+  Sun: 0,
+  Mon: 1,
+  Tue: 2,
+  Wed: 3,
+  Thu: 4,
+  Fri: 5,
+  Sat: 6
+};
+function minuteOfDay(value) {
+  const match = /^(\d{2}):(\d{2})$/.exec(value);
+  if (!match) return void 0;
+  const hour = Number(match[1]);
+  const minute = Number(match[2]);
+  if (hour > 23 || minute > 59) return void 0;
+  return hour * 60 + minute;
+}
+function clockAt(date, timezone) {
+  try {
+    const parts = new Intl.DateTimeFormat("en-US", {
+      timeZone: timezone,
+      weekday: "short",
+      hour: "2-digit",
+      minute: "2-digit",
+      hourCycle: "h23"
+    }).formatToParts(date);
+    const weekday = parts.find((part) => part.type === "weekday")?.value;
+    const hour = Number(parts.find((part) => part.type === "hour")?.value);
+    const minute = Number(parts.find((part) => part.type === "minute")?.value);
+    if (!weekday || WEEKDAYS[weekday] === void 0 || !Number.isFinite(hour + minute))
+      return void 0;
+    return { day: WEEKDAYS[weekday], minute: hour * 60 + minute };
+  } catch {
+    return void 0;
+  }
+}
+function targetMatches(rule, providerId, model) {
+  if (rule.provider && rule.provider !== providerId) return false;
+  if (rule.model && rule.model !== model) return false;
+  return Boolean(rule.provider || rule.model);
+}
+function timeMatches(rule, day, minute) {
+  const start = minuteOfDay(rule.start);
+  const end = minuteOfDay(rule.end);
+  if (start === void 0 || end === void 0) return false;
+  const days = rule.days?.length ? new Set(rule.days) : void 0;
+  if (start === end) return !days || days.has(day);
+  if (start < end) return (!days || days.has(day)) && minute >= start && minute < end;
+  if (minute >= start) return !days || days.has(day);
+  const previousDay = (day + 6) % 7;
+  return minute < end && (!days || days.has(previousDay));
+}
+function evaluateModelCalendar(rules, providerId, model, at = /* @__PURE__ */ new Date()) {
+  ({ providerId, model } = logicalCalendarTarget(providerId, model));
+  const allowRules = [];
+  let allowMatched = false;
+  for (const rule of rules ?? []) {
+    if (rule.enabled === false || !targetMatches(rule, providerId, model)) continue;
+    const clock = clockAt(at, rule.timezone);
+    if (!clock || minuteOfDay(rule.start) === void 0 || minuteOfDay(rule.end) === void 0)
+      continue;
+    if (rule.mode === "allow_only") {
+      allowRules.push(rule);
+      if (timeMatches(rule, clock.day, clock.minute)) allowMatched = true;
+    } else if (timeMatches(rule, clock.day, clock.minute)) {
+      return { allowed: false, rule };
+    }
+  }
+  if (allowRules.length > 0 && !allowMatched) return { allowed: false, rule: allowRules[0] };
+  return { allowed: true };
+}
+
 // src/core/fallback-model.ts
 function parseModelRef(ref) {
   const trimmed = ref.trim();
@@ -3157,9 +3316,9 @@ function normalizeOptions(options) {
     };
   });
 }
-function requiredInstruction(path11) {
-  const text = readBundledInstructionText(path11);
-  if (!text) throw new Error(`Council instruction file is unavailable: ${path11}`);
+function requiredInstruction(path12) {
+  const text = readBundledInstructionText(path12);
+  if (!text) throw new Error(`Council instruction file is unavailable: ${path12}`);
   return text;
 }
 
@@ -5921,12 +6080,12 @@ function verifyFiles(tokens, files) {
   const violations = [];
   let onPalette = 0;
   let offPalette = 0;
-  for (const { path: path11, text } of files) {
+  for (const { path: path12, text } of files) {
     const lines = text.split("\n");
     lines.forEach((lineText, i) => {
       const lineNo = i + 1;
       const flag = (snippet, reason) => {
-        violations.push({ file: path11, line: lineNo, snippet: snippet.slice(0, 80), reason });
+        violations.push({ file: path12, line: lineNo, snippet: snippet.slice(0, 80), reason });
       };
       for (const re of [HEX_RE, FUNC_COLOR_RE]) {
         re.lastIndex = 0;
@@ -6214,16 +6373,20 @@ function buildRecoveryStrategies(opts) {
         const delayMs = err.body?.retryAfterMs ?? 5e3;
         const delay = Math.min(6e4, Math.max(1e3, delayMs));
         if (ctx?.signal) {
-          await new Promise((resolve4) => {
+          await new Promise((resolve6) => {
             if (ctx.signal.aborted) {
-              resolve4();
+              resolve6();
               return;
             }
-            const timer = setTimeout(resolve4, delay);
-            ctx.signal.addEventListener("abort", () => {
-              clearTimeout(timer);
-              resolve4();
-            }, { once: true });
+            const timer = setTimeout(resolve6, delay);
+            ctx.signal.addEventListener(
+              "abort",
+              () => {
+                clearTimeout(timer);
+                resolve6();
+              },
+              { once: true }
+            );
           });
         } else {
           await new Promise((r) => setTimeout(r, delay));
@@ -6314,6 +6477,7 @@ function buildRecoveryStrategies(opts) {
 var DEFAULT_RECOVERY_STRATEGIES = buildRecoveryStrategies();
 var HANDLER_KIND_BY_PROVIDER_KIND = {
   rate_limit: "rate_limit",
+  quota_exhausted: "rate_limit",
   overloaded: "overloaded",
   server: "server",
   stream_hang: "server",
@@ -7923,13 +8087,13 @@ var SubagentBudget = class _SubagentBudget {
     if (!bus?.hasListenerFor("budget.threshold_reached")) {
       return Promise.resolve("stop");
     }
-    return new Promise((resolve4) => {
+    return new Promise((resolve6) => {
       let resolved = false;
       const respond = (d) => {
         if (resolved) return;
         resolved = true;
         clearTimeout(fallback);
-        resolve4(d);
+        resolve6(d);
       };
       const fallback = setTimeout(() => respond("stop"), _SubagentBudget.DECISION_TIMEOUT_MS);
       const sessionId = this.currentSessionId();
@@ -8228,8 +8392,34 @@ function makeAgentSubagentRunner(opts) {
     const taskStartedAt = Date.now();
     const factoryResult = await opts.factory(ctx.config, task);
     const { agent, events } = factoryResult;
+    const taskContext = task.context ?? {};
+    const hasExplicitTelemetryTask = typeof taskContext["telemetryTaskId"] === "string";
+    const telemetryTaskId = hasExplicitTelemetryTask ? taskContext["telemetryTaskId"] : task.id;
+    const telemetryRunId = typeof taskContext["telemetryRunId"] === "string" ? taskContext["telemetryRunId"] : void 0;
+    const telemetryBoardId = typeof taskContext["telemetryBoardId"] === "string" ? taskContext["telemetryBoardId"] : void 0;
     const agentContext = agent.ctx;
-    if (agentContext?.meta) agentContext.meta["subagentTaskId"] = task.id;
+    if (agentContext?.meta) {
+      agentContext.meta["subagentTaskId"] = task.id;
+      const kanbanContext = taskContext["kanban"];
+      if (kanbanContext && typeof kanbanContext === "object") {
+        agentContext.meta["kanban"] = kanbanContext;
+      }
+      if (hasExplicitTelemetryTask) {
+        agentContext.meta["telemetryTaskId"] = telemetryTaskId;
+        if (telemetryRunId) agentContext.meta["telemetryRunId"] = telemetryRunId;
+      }
+    }
+    if (hasExplicitTelemetryTask) {
+      agentContext?.setCurrentKanbanTask?.(telemetryTaskId, telemetryBoardId);
+    } else {
+      const kanbanContext = taskContext["kanban"];
+      if (kanbanContext && typeof kanbanContext === "object") {
+        const kanban = kanbanContext;
+        const boardId = typeof kanban["boardId"] === "string" ? kanban["boardId"] : void 0;
+        const taskId = typeof kanban["taskId"] === "string" ? kanban["taskId"] : void 0;
+        if (taskId) agentContext?.setCurrentKanbanTask?.(taskId, boardId);
+      }
+    }
     const detachFleet = opts.fleetBus?.attach(ctx.subagentId, events, task.id);
     const aborter = new AbortController();
     ctx.budget._events = events;
@@ -8254,6 +8444,27 @@ function makeAgentSubagentRunner(opts) {
     const unsub = [];
     unsub.push(
       events.on("tool.executed", (e) => {
+        if (hasExplicitTelemetryTask) {
+          opts.hostEvents?.emit("subagent.tool_executed", {
+            sessionId: e.sessionId,
+            subagentId: ctx.subagentId,
+            agentSessionId: e.sessionId,
+            agentName: e.agentName ?? ctx.config.name,
+            taskId: telemetryTaskId,
+            runId: telemetryRunId,
+            traceId: e.traceId,
+            id: e.id,
+            name: e.name,
+            durationMs: e.durationMs,
+            ok: e.ok,
+            // Raw tool inputs may contain credentials or sensitive arguments.
+            // Task telemetry crosses from the isolated worker bus to the shared
+            // host bus, so expose only execution metadata at this boundary.
+            outputBytes: e.outputBytes,
+            outputTokens: e.outputTokens,
+            outputLines: e.outputLines
+          });
+        }
         try {
           ctx.budget.recordToolCall();
         } catch (eb) {
@@ -8265,6 +8476,17 @@ function makeAgentSubagentRunner(opts) {
           lastToolFailed = null;
         }
       }),
+      events.on("file.event", (e) => {
+        if (!hasExplicitTelemetryTask) return;
+        if (e.runId === telemetryRunId && e.taskId === telemetryTaskId) return;
+        opts.hostEvents?.emit("file.event", {
+          ...e,
+          scope: "task",
+          taskId: telemetryTaskId,
+          boardId: telemetryBoardId,
+          runId: telemetryRunId
+        });
+      }),
       events.on("provider.response", (e) => {
         try {
           ctx.budget.recordUsage(e.usage);
@@ -9558,6 +9780,40 @@ var DOMAIN_AGENTS = [
         "information architecture"
       ]
     }
+  },
+  {
+    config: {
+      id: "ios",
+      name: "iOS",
+      role: "ios",
+      tools: [...TOOLS.build, "fetch"],
+      prompt: agentPrompt("ios")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "Apple-platform app development in Swift against the latest Xcode/iOS-SDK line: SwiftUI, UIKit, SwiftData, concurrency, accessibility, and App Store submission.",
+      keywords: [
+        "ios",
+        "iphone",
+        "ipad",
+        "ipados",
+        "watchos",
+        "tvos",
+        "visionos",
+        "macos",
+        "swift",
+        "swiftui",
+        "uikit",
+        "xcode",
+        "swiftdata",
+        "app store",
+        "app intents",
+        "swift package manager",
+        "cocoapods",
+        "foundation models"
+      ]
+    }
   }
 ];
 
@@ -10166,6 +10422,7 @@ function classifySubagentError(err, hints = {}) {
 function providerErrorToSubagentError(err, message, cause) {
   switch (err.kind) {
     case "rate_limit":
+    case "quota_exhausted":
       return {
         kind: "provider_rate_limit",
         message,
@@ -10665,7 +10922,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       taskIds.map((id) => {
         const cached = this.completedResults.find((r) => r.taskId === id);
         if (cached) return cached;
-        return new Promise((resolve4, reject) => {
+        return new Promise((resolve6, reject) => {
           const timeout = setTimeout(() => {
             this.off("task.completed", handler);
             reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
@@ -10674,7 +10931,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             if (result.taskId === id) {
               clearTimeout(timeout);
               this.off("task.completed", handler);
-              resolve4(result);
+              resolve6(result);
             }
           };
           this.on("task.completed", handler);
@@ -10699,13 +10956,13 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       const done = new Set(completed.map((r) => r.taskId));
       return { completed, pending: taskIds.filter((id) => !done.has(id)) };
     }
-    return new Promise((resolve4) => {
+    return new Promise((resolve6) => {
       let timer;
       const handler = ({ result }) => {
         if (!ids.has(result.taskId)) return;
         if (timer) clearTimeout(timer);
         this.off("task.completed", handler);
-        resolve4({
+        resolve6({
           completed: [result],
           pending: taskIds.filter((id) => id !== result.taskId)
         });
@@ -10713,7 +10970,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       if (opts?.timeoutMs !== void 0) {
         timer = setTimeout(() => {
           this.off("task.completed", handler);
-          resolve4({ completed: [], pending: [...taskIds], timedOut: true });
+          resolve6({ completed: [], pending: [...taskIds], timedOut: true });
         }, opts.timeoutMs);
       }
       this.on("task.completed", handler);
@@ -10995,12 +11252,12 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             }
             return new Promise((resolveDecision) => {
               let settled = false;
-              const resolve4 = (d) => {
+              const resolve6 = (d) => {
                 if (settled) return;
                 settled = true;
                 resolveDecision(d);
               };
-              const fallback = setTimeout(() => resolve4("stop"), DECISION_TIMEOUT_MS);
+              const fallback = setTimeout(() => resolve6("stop"), DECISION_TIMEOUT_MS);
               const sessionId = this.currentSessionId();
               budget._events?.emit("budget.threshold_reached", {
                 ...sessionId ? { sessionId } : {},
@@ -11018,11 +11275,11 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
                 // disagreeing, resolves as a stop). Async grants still resolve.
                 extend: (extra) => {
                   clearTimeout(fallback);
-                  queueMicrotask(() => resolve4({ extend: extra }));
+                  queueMicrotask(() => resolve6({ extend: extra }));
                 },
                 deny: () => {
                   clearTimeout(fallback);
-                  resolve4("stop");
+                  resolve6("stop");
                 }
               });
             });
@@ -11690,6 +11947,7 @@ import { randomInt } from "node:crypto";
 var MAX_RETRY_AFTER_MS = 6e4;
 var MAX_ATTEMPTS_BY_KIND = {
   rate_limit: 5,
+  quota_exhausted: 0,
   stream_hang: 5,
   // transient, worth retrying aggressively
   overloaded: 3,
@@ -12428,7 +12686,9 @@ var DefaultSkillLoader = class {
     const seen = /* @__PURE__ */ new Set();
     for (const { dir, source, originTool } of this.dirs) {
       try {
-        const entries = await fs5.readdir(dir, { withFileTypes: true });
+        const entries = (await fs5.readdir(dir, { withFileTypes: true })).sort(
+          (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0
+        );
         for (const e of entries) {
           if (!await entryIsDirectory(dir, e)) continue;
           const skillFile = path7.join(dir, e.name, "SKILL.md");
@@ -13055,7 +13315,7 @@ function readPolicy(ctx) {
 }
 
 // src/execution/tool-executor.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash2, randomUUID as randomUUID3 } from "node:crypto";
 
 // src/observability/process-telemetry.ts
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -13074,7 +13334,166 @@ function runWithNetworkTelemetry(context, run) {
 // src/execution/tool-executor.ts
 import { isDeepStrictEqual } from "node:util";
 import * as fs8 from "node:fs/promises";
+import * as path11 from "node:path";
+
+// src/security/kanban-boundary.ts
+import { realpath } from "node:fs/promises";
 import * as path10 from "node:path";
+import {
+  evaluateKanbanBoundaryOpaque,
+  evaluateKanbanBoundaryPath,
+  readBoard,
+  resolveKanbanBoundaryLayers
+} from "@wrongstack/kanban";
+var PATH_KEYS = /* @__PURE__ */ new Set([
+  "path",
+  "paths",
+  "file",
+  "files",
+  "directory",
+  "dir",
+  "cwd",
+  "root",
+  "baseDir",
+  "out",
+  "outputPath",
+  "sourcePath",
+  "targetPath",
+  "destinationPath",
+  "fromPath",
+  "toPath",
+  "worktreePath"
+]);
+var TOOL_PATH_KEYS = {
+  // `target` is an identifier in tools such as plan/task/document, but a
+  // filesystem target in language_info. Keep ambiguous names tool-specific.
+  language_info: ["target"]
+};
+async function evaluateToolKanbanBoundary(tool, input, ctx) {
+  const identity = resolveKanbanIdentity(ctx);
+  if (!identity.boardId) return { decision: "allow" };
+  const board = await readBoard(identity.policyRoot ?? ctx.projectRoot, identity.boardId);
+  if (!board) return { decision: "allow" };
+  const task = identity.taskId ? board.tasks.find((candidate) => candidate.id === identity.taskId) : void 0;
+  const layers = resolveKanbanBoundaryLayers(board, task);
+  if (layers.length === 0) return { decision: "allow" };
+  const caps = tool.capabilities ?? [];
+  const access2 = caps.includes("fs.write") || caps.includes("fs.write.outside-project") ? "write" : caps.includes("fs.read") ? "read" : void 0;
+  const shellLike = caps.some((capability) => capability.startsWith("shell."));
+  const candidates = access2 ? await extractCandidatePaths(tool.name, input, ctx) : [];
+  let evaluation;
+  if (shellLike || access2 && candidates.length === 0) {
+    evaluation = evaluateKanbanBoundaryOpaque(layers, tool.name);
+  } else if (access2) {
+    const results = candidates.map(
+      (candidate) => evaluateKanbanBoundaryPath(layers, candidate, access2)
+    );
+    evaluation = results.find((result) => result.decision === "block") ?? results.find((result) => result.decision === "confirm") ?? { decision: "allow" };
+  } else {
+    evaluation = { decision: "allow" };
+  }
+  return {
+    ...evaluation,
+    boardId: board.id,
+    ...task ? { taskId: task.id } : {}
+  };
+}
+function resolveKanbanIdentity(ctx) {
+  const metaKanban = ctx.meta["kanban"];
+  const record = metaKanban && typeof metaKanban === "object" ? metaKanban : void 0;
+  const boardId = ctx.currentKanbanBoardId ?? (typeof record?.["boardId"] === "string" ? record["boardId"] : void 0);
+  const taskId = ctx.currentKanbanTaskId ?? (typeof record?.["taskId"] === "string" ? record["taskId"] : void 0);
+  const policyRoot = typeof record?.["projectRoot"] === "string" ? record["projectRoot"] : void 0;
+  return {
+    ...boardId ? { boardId } : {},
+    ...taskId ? { taskId } : {},
+    ...policyRoot ? { policyRoot } : {}
+  };
+}
+async function extractCandidatePaths(toolName, input, ctx) {
+  if (toolName === "patch" && typeof input["patch"] === "string") {
+    const directoryInput = stringValue(input["directory"]) ?? ctx.workingDir;
+    const directory = path10.isAbsolute(directoryInput) ? directoryInput : path10.resolve(ctx.workingDir, directoryInput);
+    const strip = Math.max(1, numericValue(input["strip"]) ?? 1);
+    const targets = extractPatchTargets(input["patch"], strip).map(
+      (target) => relativeToProject(path10.resolve(directory, target), ctx.projectRoot)
+    );
+    return Promise.all(targets.map((target) => canonicalizeCandidatePath(target, ctx)));
+  }
+  const values = [];
+  const pathKeys = new Set(PATH_KEYS);
+  for (const key of TOOL_PATH_KEYS[toolName] ?? []) pathKeys.add(key);
+  collectPathValues(input, values, pathKeys);
+  if (toolName === "scaffold" && typeof input["name"] === "string") {
+    const cwd = stringValue(input["cwd"]) ?? ctx.workingDir;
+    values.push(path10.join(cwd, input["name"]));
+  }
+  const candidates = [
+    ...new Set(values.flatMap(splitPathList).map((value) => resolveInputPath(value, ctx)))
+  ];
+  return Promise.all(candidates.map((candidate) => canonicalizeCandidatePath(candidate, ctx)));
+}
+async function canonicalizeCandidatePath(candidate, ctx) {
+  if (path10.isAbsolute(candidate)) return candidate;
+  const absolute = path10.resolve(ctx.projectRoot, candidate);
+  const canonicalRoot = await realpath(ctx.projectRoot).catch(() => ctx.projectRoot);
+  let probe = absolute;
+  const missingSegments = [];
+  while (true) {
+    try {
+      const canonical = path10.join(await realpath(probe), ...missingSegments);
+      return relativeToProject(canonical, canonicalRoot);
+    } catch (cause) {
+      const code = cause.code;
+      if (code !== "ENOENT" && code !== "ENOTDIR") return absolute;
+      const parent = path10.dirname(probe);
+      if (parent === probe) return absolute;
+      missingSegments.unshift(path10.basename(probe));
+      probe = parent;
+    }
+  }
+}
+function collectPathValues(value, output, pathKeys, key) {
+  if (typeof value === "string") {
+    if (key && pathKeys.has(key)) output.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectPathValues(item, output, pathKeys, key);
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+  for (const [childKey, child] of Object.entries(value)) {
+    collectPathValues(child, output, pathKeys, childKey);
+  }
+}
+function splitPathList(value) {
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function resolveInputPath(value, ctx) {
+  const absolute = path10.isAbsolute(value) ? value : path10.resolve(ctx.workingDir, value);
+  return relativeToProject(absolute, ctx.projectRoot);
+}
+function relativeToProject(absolute, projectRoot) {
+  const relative2 = path10.relative(projectRoot, absolute).replace(/\\/g, "/");
+  return relative2.startsWith("../") || path10.isAbsolute(relative2) ? absolute : relative2 || ".";
+}
+function extractPatchTargets(patchText, strip) {
+  const targets = [];
+  for (const match of patchText.matchAll(/^\+\+\+\s+([^\t\r\n]+)/gm)) {
+    const raw = match[1]?.trim();
+    if (!raw || raw === "/dev/null") continue;
+    const parts = raw.replace(/\\/g, "/").split("/").filter((part) => part && part !== ".");
+    if (parts.length > strip) targets.push(parts.slice(strip).join("/"));
+  }
+  return targets;
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function numericValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
 
 // src/types/tool-executor.ts
 var GOVERNED_TOOL_EXECUTOR_META_KEY = "toolExecutor.executeGoverned";
@@ -13295,35 +13714,68 @@ ${errorDetails}`,
           return { result, tool, durationMs: Date.now() - start };
         }
       }
+      const boundary = await evaluateToolKanbanBoundary(tool, use.input, ctx);
+      if (boundary.decision === "block") {
+        const result = {
+          type: "tool_result",
+          tool_use_id: use.id,
+          content: `Tool "${tool.name}" blocked by Kanban boundary. ${boundary.reason ?? ""}`.trim(),
+          is_error: true
+        };
+        budget = this.budgetForString(result.content, budget);
+        return { result, tool, durationMs: Date.now() - start };
+      }
       const decision = await this.opts.permissionPolicy.evaluate(tool, use.input, ctx);
       let effectivePermission = decision.permission;
       const policy = this.opts.permissionPolicy;
       const yolo = policy.getYolo?.() === true;
       const authoritativeAuto = decision.source === "yolo";
-      if (toolDangerousCaps.length > 0 && effectivePermission === "auto" && !yolo && !authoritativeAuto) {
+      const capabilityDowngraded = toolDangerousCaps.length > 0 && effectivePermission === "auto" && !yolo && !authoritativeAuto;
+      if (capabilityDowngraded) {
+        effectivePermission = "confirm";
+      }
+      if (boundary.decision === "confirm" && effectivePermission !== "deny") {
         effectivePermission = "confirm";
       }
+      this.opts.events?.emit("permission.evaluated", {
+        sessionId: ctx.session.id,
+        ...ctx.traceId ? { traceId: ctx.traceId } : {},
+        ...ctx.agentId ? { agentId: ctx.agentId } : {},
+        name: tool.name,
+        id: use.id,
+        inputHash: hashPermissionInput(use.input, this.opts.secretScrubber),
+        policyDecision: decision.permission,
+        effectiveDecision: effectivePermission,
+        decisionSource: decision.source,
+        ...decision.reason ? { reason: decision.reason } : {},
+        ...decision.riskTier ?? tool.riskTier ? { riskTier: decision.riskTier ?? tool.riskTier } : {},
+        yoloEnabled: yolo,
+        boundaryDecision: boundary.decision,
+        ...boundary.reason ? { boundaryReason: boundary.reason } : {},
+        capabilityDowngraded
+      });
       if (effectivePermission === "deny") {
         const result = this.deniedResult(use, decision.reason);
         budget = this.budgetForString(result.content, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
       if (effectivePermission === "confirm") {
+        const suggestedPattern = boundary.decision === "confirm" ? `kanban-boundary:${boundary.path ?? tool.name}` : subjectForToolInput(tool.name, use.input, tool.subjectKey) ?? tool.name;
         if (this.opts.confirmAwaiter) {
           const awaiter = this.opts.confirmAwaiter;
           const choice = await new Promise(
-            (resolve4, reject) => {
+            (resolve6, reject) => {
               const signal = ctx.signal;
-              const onAbort = () => resolve4("abort");
+              const onAbort = () => resolve6("abort");
               if (signal.aborted) {
-                resolve4("abort");
+                resolve6("abort");
                 return;
               }
               signal.addEventListener("abort", onAbort, { once: true });
-              awaiter(tool, use.input, use.id, tool.name).then(
+              awaiter(tool, use.input, use.id, suggestedPattern).then(
                 (c) => {
                   signal.removeEventListener("abort", onAbort);
-                  resolve4(c);
+                  resolve6(c);
                 },
                 (e) => {
                   signal.removeEventListener("abort", onAbort);
@@ -13343,7 +13795,6 @@ ${errorDetails}`,
             return { result, tool, durationMs: Date.now() - start };
           }
         } else {
-          const suggestedPattern = subjectForToolInput(tool.name, use.input, tool.subjectKey) ?? tool.name;
           const pending = {
             type: "tool_confirm_pending",
             toolUseId: use.id,
@@ -13351,7 +13802,8 @@ ${errorDetails}`,
             input: use.input,
             suggestedPattern,
             decisionSource: decision.source,
-            riskTier: decision.riskTier ?? tool.riskTier
+            riskTier: decision.riskTier ?? tool.riskTier,
+            ...boundary.decision === "confirm" && boundary.reason ? { boundaryReason: boundary.reason } : {}
           };
           return { result: pending, tool, durationMs: Date.now() - start };
         }
@@ -13365,6 +13817,17 @@ ${errorDetails}`,
         "tool.has_dangerous_capabilities": toolCapsForAudit.length > 0
       });
       try {
+        const inputPath = use.input && typeof use.input === "object" ? use.input.path : void 0;
+        const caps = tool.capabilities ?? [];
+        const hasFileCapability = caps.includes("fs.read") || caps.includes("fs.write");
+        const absPath = hasFileCapability && typeof inputPath === "string" ? path11.isAbsolute(inputPath) ? inputPath : path11.resolve(ctx.projectRoot, inputPath) : void 0;
+        let writeTargetExisted;
+        if (tool.name === "write" && caps.includes("fs.write") && absPath) {
+          writeTargetExisted = await fs8.stat(absPath).then(
+            (stat4) => stat4.isFile(),
+            (error) => error.code === "ENOENT" ? false : void 0
+          );
+        }
         const producedText = await this.produceToolOutput(tool, use, ctx, budget);
         let { block: result, bytes } = this.settleToolOutput(tool, use, producedText, budget);
         budget -= bytes;
@@ -13393,6 +13856,35 @@ ${post.additionalContext}`;
         span?.setAttribute("tool.is_error", !!result.is_error);
         span?.setAttribute("tool.output_bytes", outputChars);
         this.logToolSuccess(ctx, use, tool.name, Date.now() - start, outputChars);
+        if (!result.is_error && typeof inputPath === "string" && absPath) {
+          const operation = tool.name === "read" ? "read" : caps.includes("fs.write") && tool.name === "write" ? writeTargetExisted === false ? "create" : "update" : caps.includes("fs.write") ? "update" : "read";
+          const ts = (/* @__PURE__ */ new Date()).toISOString();
+          ctx.recordFileEvent?.({
+            operation,
+            filePath: inputPath,
+            absPath,
+            toolName: tool.name,
+            toolUseId: use.id,
+            durationMs: Date.now() - start
+          });
+          this.opts.events?.emit("file.event", {
+            operation,
+            filePath: inputPath,
+            absPath,
+            sessionId: ctx.session.id,
+            agentId: ctx.agentId,
+            agentName: ctx.agentName,
+            provider: typeof ctx.provider === "object" ? ctx.provider.id : String(ctx.provider),
+            model: ctx.model,
+            toolName: tool.name,
+            toolUseId: use.id,
+            scope: ctx.currentKanbanTaskId ? "task" : "session",
+            taskId: ctx.currentKanbanTaskId,
+            boardId: ctx.currentKanbanBoardId,
+            timestamp: ts,
+            durationMs: Date.now() - start
+          });
+        }
         return { result, tool, durationMs: Date.now() - start };
       } catch (err) {
         if (isWrongStackError(err)) {
@@ -13621,7 +14113,7 @@ ${post.additionalContext}`;
     toolPromise.catch(() => {
     });
     try {
-      output = await new Promise((resolve4, reject) => {
+      output = await new Promise((resolve6, reject) => {
         const onAbort = () => {
           setTimeout(() => reject(abortReasonToError(combined.reason)), 0);
         };
@@ -13629,7 +14121,7 @@ ${post.additionalContext}`;
         toolPromise.then(
           (v) => {
             combined.removeEventListener("abort", onAbort);
-            resolve4(v);
+            resolve6(v);
           },
           (e) => {
             combined.removeEventListener("abort", onAbort);
@@ -13920,11 +14412,11 @@ async function maybePersistLargeToolOutput(toolName, content, budget) {
     return content;
   }
   try {
-    const dir = path10.join(wstackGlobalRoot(), "tool-output");
+    const dir = path11.join(wstackGlobalRoot(), "tool-output");
     await fs8.mkdir(dir, { recursive: true });
     const safeTool = toolName.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 40) || "tool";
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const filePath = path10.join(dir, `${stamp}-${safeTool}-${randomUUID3()}.log`);
+    const filePath = path11.join(dir, `${stamp}-${safeTool}-${randomUUID3()}.log`);
     await fs8.writeFile(filePath, content, "utf8");
     const marker = `[full tool output: ${bytes} bytes at ${filePath}; read/grep that file selectively instead of re-running or requesting more output]`;
     const fixedBytes = Buffer.byteLength(marker + TOOL_OUTPUT_ARTIFACT_OMISSION, "utf8");
@@ -13943,6 +14435,15 @@ ${head}${TOOL_OUTPUT_ARTIFACT_OMISSION}${tail}`;
     return content;
   }
 }
+function hashPermissionInput(input, scrubber) {
+  let serialized;
+  try {
+    serialized = JSON.stringify(input) ?? "";
+  } catch {
+    serialized = String(input);
+  }
+  return createHash2("sha256").update(scrubber.scrub(serialized), "utf8").digest("hex");
+}
 function sliceUtf8Prefix(text, maxBytes) {
   if (maxBytes <= 0) return "";
   if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
@@ -14024,14 +14525,20 @@ var OneShotOrchestrator = class {
     let servingProviderId = provider.id;
     let servingModel = target.model;
     let fromFallback = false;
-    let lastError = void 0;
+    let lastError;
     let fallbackEligible = false;
-    if (tracker && !tracker.isAvailable(target.providerId, target.model)) {
+    if (tracker && !tracker.isAvailable(target.providerId, target.model) || !evaluateModelCalendar(config.modelAvailabilitySchedule, target.providerId, target.model).allowed) {
       this.opts.logger?.debug(
         `one-shot: primary "${target.providerId}/${target.model}" is blocked \u2014 trying fallback`
       );
     } else {
-      const primaryAttempt = await this.tryCall(provider, request, signal, target.providerId, target.model);
+      const primaryAttempt = await this.tryCall(
+        provider,
+        request,
+        signal,
+        target.providerId,
+        target.model
+      );
       const result = primaryAttempt.response;
       lastError = primaryAttempt.error;
       fallbackEligible = primaryAttempt.fallbackEligible;
@@ -14042,17 +14549,13 @@ var OneShotOrchestrator = class {
         return this.buildResult(result, servingProviderId, servingModel, false, startedAt);
       }
       if (!fallbackEligible || chain.length === 0) {
-        return this.buildErrorResult(
-          lastError,
-          target.providerId,
-          target.model,
-          false,
-          startedAt
-        );
+        return this.buildErrorResult(lastError, target.providerId, target.model, false, startedAt);
       }
     }
     const usableChain = tracker ? chain.filter((e) => tracker.isAvailable(e.providerId, e.model)) : chain;
     for (const entry of usableChain) {
+      if (!evaluateModelCalendar(config.modelAvailabilitySchedule, entry.providerId, entry.model).allowed)
+        continue;
       if (entry.providerId === provider.id && entry.model === target.model) continue;
       let fbProvider;
       try {
@@ -14079,7 +14582,13 @@ var OneShotOrchestrator = class {
       fallbackEligible = attempt.fallbackEligible;
       if (!fallbackEligible) break;
     }
-    return this.buildErrorResult(lastError, servingProviderId, servingModel, fromFallback, startedAt);
+    return this.buildErrorResult(
+      lastError,
+      servingProviderId,
+      servingModel,
+      fromFallback,
+      startedAt
+    );
   }
   // ── Private helpers ─────────────────────────────────────────────
   /**