@event4u/agent-config 9.29.0 → 9.30.0

package/dist/cli-delegate/{chunk-MMXA5GY7.js → chunk-DDUNNFYX.js}

@@ -4374,6 +4374,9 @@ var settingsSchema = external_exports.object({
     judge_model: external_exports.string().default("").describe(
       "Override the model used for review / judge subagents that critique implementer output. Empty (default) = one tier above the implementer model \u2014 picks up nuance the implementer missed."
     ),
+    model_ceiling: external_exports.string().default("").describe(
+      "Session-wide model CEILING for subagents (spend cap). Empty (default) = no ceiling. When set, suite-owned CLI spawn wrappers export CLAUDE_CODE_SUBAGENT_MODEL to the sessions they launch. Class C: a human sets it; the agent never writes or infers one."
+    ),
     max_parallel: external_exports.number().int().min(1).default(3).describe(
       "Hard cap on subagents running in parallel during /do-in-parallel, /do-competitively, and /judge runs. Raise for faster fan-out, lower if you hit rate limits or want lower token spend."
     ),
@@ -4540,6 +4543,17 @@ var settingsSchema = external_exports.object({
       enabled: external_exports.boolean().default(false).describe(
         "PreToolUse code-graph nudge (ADR-124 Phase 4). Default off. When on AND a native code-graph cache or a consumer-shipped graph.json/SCIP index is present, warns once per session (never blocks) as the agent is about to Grep/Glob or Read a source file \u2014 query the graph first for who-calls/where-used/impact questions (or rebuild if stale, build if absent). Source G\u2019s strict block-first-read mode is deliberately un-ported."
       )
+    }).default({}),
+    turn_end_gate: external_exports.object({
+      enabled: external_exports.boolean().default(false).describe(
+        "Stop-slot turn-end gate (road-to-conformance-round5 Phase 3). Default off, and it is the only concern that can REFUSE a turn-end rather than a tool call \u2014 so it soaks behind an explicit opt-in before it binds. Round 5 measured the reason: both blocking carriers reached zero violations, neither advisory carrier did, and 19 wrong-language replies survived a pin that had fired 26-35 seconds earlier. A refused turn continues in the SAME turn and is never refused twice."
+      ),
+      promissory: external_exports.boolean().default(true).describe(
+        "Detector A of the turn-end gate: refuse a turn whose closing paragraph promises work not yet performed while asking the user nothing (20 measured occurrences). Inert while hooks.turn_end_gate.enabled is false."
+      ),
+      language: external_exports.boolean().default(true).describe(
+        "Detector B of the turn-end gate: refuse a turn whose user-visible prose is not in the pinned language, with fenced code, inline code, quoted tool output, tables, URLs, paths and identifiers excluded first (19 measured occurrences). Fires 18.0% of turns on the measured corpus, which is why the master switch is off by default. Inert while hooks.turn_end_gate.enabled is false."
+      )
     }).default({})
   }),
   decision_engine: external_exports.object({

package/dist/cli-delegate/{chunk-NZ5N2XQL.js → chunk-EQY4FLJB.js}

@@ -2,7 +2,7 @@ import { createRequire as __acCreateRequire } from 'node:module'; const require
 import {
   ZodFirstPartyTypeKind,
   settingsSchema
-} from "./chunk-MMXA5GY7.js";
+} from "./chunk-DDUNNFYX.js";
 import {
   main
 } from "./chunk-MP3JT3IU.js";

package/dist/cli-delegate/{chunk-RCIA67XN.js → chunk-IYTGIG2Y.js}

@@ -41,6 +41,7 @@ import {
   ProjectRootError,
   ROOT_OVERRIDE_ENV,
   find_project_root_with_trace,
+  load_agent_settings,
   project_settings_path,
   resolve_project_root
 } from "./chunk-LCFJIQ4J.js";
@@ -186,7 +187,9 @@ __export(clients_exports, {
   _OpenAICompatibleClient: () => _OpenAICompatibleClient,
   _is_reasoning_model: () => _is_reasoning_model,
   _read_until_marker: () => _read_until_marker,
+  _resetModelCeilingMemo: () => _resetModelCeilingMemo,
   _setMonotonicSource: () => _setMonotonicSource,
+  _subagentModelCeiling: () => _subagentModelCeiling,
   _today_utc_iso: () => _today_utc_iso,
   assertCacheBreakpointOrder: () => assertCacheBreakpointOrder,
   load_anthropic_key: () => load_anthropic_key,
@@ -200,6 +203,9 @@ import { spawnSync } from "node:child_process";
 import * as fs4 from "node:fs";
 import * as path4 from "node:path";
 
+// src/scripts/_lib/session_role.ts
+var SESSION_ROLE_ENV = "AGENT_CONFIG_SESSION_ROLE";
+
 // src/scripts/ai_council/events_log.ts
 import * as crypto from "node:crypto";
 import * as fs3 from "node:fs";
@@ -405,6 +411,25 @@ function _pyJsonStringRaw(s) {
 }
 
 // src/scripts/ai_council/clients.ts
+var _modelCeilingMemo = /* @__PURE__ */ new Map();
+function _subagentModelCeiling(cwd = process.cwd()) {
+  const hit = _modelCeilingMemo.get(cwd);
+  if (hit !== void 0) return hit;
+  let ceiling;
+  try {
+    const settings = load_agent_settings({ cwd });
+    const sub = settings["subagents"] ?? {};
+    const v = typeof sub["model_ceiling"] === "string" ? sub["model_ceiling"].trim() : "";
+    ceiling = v.length > 0 ? v : null;
+  } catch {
+    ceiling = null;
+  }
+  _modelCeilingMemo.set(cwd, ceiling);
+  return ceiling;
+}
+function _resetModelCeilingMemo() {
+  _modelCeilingMemo.clear();
+}
 var ANTHROPIC_KEY_FILENAME = "anthropic.key";
 var OPENAI_KEY_FILENAME = "openai.key";
 var ANTHROPIC_KEY_PATH = write_target(ANTHROPIC_KEY_FILENAME);
@@ -1150,7 +1175,25 @@ var CliClient = class extends ExternalAIClient {
       // (loader preload, git *_COMMAND, NODE_OPTIONS, …) so an
       // attacker-influenced parent env cannot RCE via the spawned CLI
       // or a `git` it invokes internally.
-      env: hardenedSpawnEnv()
+      // Role marking (token-economy-dispatch Phase 2.2): a council
+      // member CLI session is worker-class — it never talks to OUR
+      // user, never dispatches sub-workers, never runs a council.
+      // The spawned vendor CLI loads this repo's hook chains; the
+      // marker lets the dispatcher run the thinner worker chain
+      // (manifest `roles.worker.drop`; pre_tool_use guards are
+      // structurally exempt). This is the ONE in-tree spawn point
+      // that launches a separate CLI session today — Agent-tool
+      // subagents share the host process env and cannot be marked
+      // (probed live 2026-08-10; see _lib/session_role.ts).
+      // The optional model ceiling (subagents.model_ceiling, class C)
+      // rides the same spawn: a spend cap the human set per install.
+      env: hardenedSpawnEnv({
+        [SESSION_ROLE_ENV]: "worker",
+        ...(() => {
+          const ceiling = _subagentModelCeiling();
+          return ceiling !== null ? { CLAUDE_CODE_SUBAGENT_MODEL: ceiling } : {};
+        })()
+      })
     };
     if (stdinPayload !== null) {
       spawnOpts.input = stdinPayload;

package/dist/cli-delegate/chunk-MMJL4TIX.js

@@ -0,0 +1,18 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/scripts/hooks/hook_stdin.ts
+import * as fs from "node:fs";
+var _override = null;
+function readHookStdin() {
+  if (_override !== null) return _override;
+  try {
+    if (process.stdin.isTTY) return "";
+    return fs.readFileSync(0, "utf-8");
+  } catch {
+    return "";
+  }
+}
+
+export {
+  readHookStdin
+};

package/dist/cli-delegate/chunk-O3CO5BFB.js

@@ -0,0 +1,161 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/scripts/hooks/state_io.ts
+import fs from "node:fs";
+import path from "node:path";
+var LOCK_BASENAME = ".dispatcher.lock";
+var REPLAY_ENV_VAR = "AGENT_CONFIG_REPLAY";
+function is_replay_mode() {
+  return (process.env[REPLAY_ENV_VAR] ?? "").trim() === "1";
+}
+function _lock_path(state_dir) {
+  return path.join(state_dir, LOCK_BASENAME);
+}
+function _py_json_dumps(value, indent) {
+  const pad = " ".repeat(indent);
+  const escapeString = (s) => {
+    let out = '"';
+    for (const ch of s) {
+      const code = ch.codePointAt(0);
+      switch (ch) {
+        case '"':
+          out += '\\"';
+          break;
+        case "\\":
+          out += "\\\\";
+          break;
+        case "\n":
+          out += "\\n";
+          break;
+        case "\r":
+          out += "\\r";
+          break;
+        case "	":
+          out += "\\t";
+          break;
+        case "\b":
+          out += "\\b";
+          break;
+        case "\f":
+          out += "\\f";
+          break;
+        default:
+          if (code < 32 || code > 126) {
+            if (code > 65535) {
+              const c = code - 65536;
+              const hi = 55296 + (c >> 10);
+              const lo = 56320 + (c & 1023);
+              out += "\\u" + hi.toString(16).padStart(4, "0") + "\\u" + lo.toString(16).padStart(4, "0");
+            } else {
+              out += "\\u" + code.toString(16).padStart(4, "0");
+            }
+          } else {
+            out += ch;
+          }
+      }
+    }
+    return out + '"';
+  };
+  const render = (v, depth) => {
+    if (v === null || v === void 0) {
+      return "null";
+    }
+    if (typeof v === "boolean") {
+      return v ? "true" : "false";
+    }
+    if (typeof v === "number") {
+      if (!Number.isFinite(v)) {
+        if (Number.isNaN(v)) return "NaN";
+        return v > 0 ? "Infinity" : "-Infinity";
+      }
+      return String(v);
+    }
+    if (typeof v === "string") {
+      return escapeString(v);
+    }
+    const curPad = pad.repeat(depth + 1);
+    const closePad = pad.repeat(depth);
+    if (Array.isArray(v)) {
+      if (v.length === 0) {
+        return "[]";
+      }
+      const items = v.map((item) => curPad + render(item, depth + 1));
+      return "[\n" + items.join(",\n") + "\n" + closePad + "]";
+    }
+    if (typeof v === "object") {
+      const obj = v;
+      const keys = Object.keys(obj);
+      if (keys.length === 0) {
+        return "{}";
+      }
+      const items = keys.map(
+        (k) => curPad + escapeString(k) + ": " + render(obj[k], depth + 1)
+      );
+      return "{\n" + items.join(",\n") + "\n" + closePad + "}";
+    }
+    throw new TypeError(`Object of type ${typeof v} is not JSON serializable`);
+  };
+  return render(value, 0);
+}
+function atomic_write_json(target, payload, options = {}) {
+  if (is_replay_mode()) {
+    return;
+  }
+  const indent = options.indent ?? 2;
+  const targetPath = path.resolve(target);
+  const state_dir = path.dirname(targetPath);
+  fs.mkdirSync(state_dir, { recursive: true });
+  const body = _py_json_dumps(payload, indent) + "\n";
+  _atomic_write_text(targetPath, body);
+}
+function _acquire_lock(lock_path) {
+  const fd = fs.openSync(lock_path, "a", 420);
+  const held = lock_path + ".held";
+  const deadlineMs = 5e3;
+  const start = Date.now();
+  for (; ; ) {
+    try {
+      const heldFd = fs.openSync(held, "wx", 420);
+      fs.closeSync(heldFd);
+      return fd;
+    } catch (err) {
+      if (err.code !== "EEXIST") {
+        return fd;
+      }
+      if (Date.now() - start > deadlineMs) {
+        try {
+          fs.rmSync(held, { force: true });
+        } catch {
+        }
+        continue;
+      }
+      const sab = new Int32Array(new SharedArrayBuffer(4));
+      Atomics.wait(sab, 0, 0, 2);
+    }
+  }
+}
+function _release_lock(fd, lock_path) {
+  try {
+    fs.closeSync(fd);
+  } catch {
+  }
+  try {
+    fs.rmSync(lock_path + ".held", { force: true });
+  } catch {
+  }
+}
+function _atomic_write_text(target, text) {
+  const tmp = target + `.tmp.${process.pid}`;
+  const lock_path = _lock_path(path.dirname(target));
+  const fd = _acquire_lock(lock_path);
+  try {
+    fs.writeFileSync(tmp, text, { encoding: "utf-8" });
+    fs.renameSync(tmp, target);
+  } finally {
+    _release_lock(fd, lock_path);
+  }
+}
+
+export {
+  atomic_write_json
+};

package/dist/cli-delegate/{chunk-REKCMYOU.js → chunk-PFBV6XRT.js}

@@ -422,6 +422,11 @@ var binaryTag = defineScalarTag("tag:yaml.org,2002:binary", {
 });
 var YAML_DATE_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$");
 var YAML_TIMESTAMP_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");
+function makeUtcDate(year, month, day, hour = 0, minute = 0, second = 0, fraction = 0) {
+  const date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
+  date.setUTCFullYear(year, month, day);
+  return date;
+}
 function resolveYamlTimestamp(source) {
   let match = YAML_DATE_REGEXP.exec(source);
   if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(source);
@@ -430,7 +435,7 @@ function resolveYamlTimestamp(source) {
   const month = +match[2] - 1;
   const day = +match[3];
   if (!match[4]) {
-    const date2 = new Date(Date.UTC(year, month, day));
+    const date2 = makeUtcDate(year, month, day);
     if (date2.getUTCFullYear() !== year || date2.getUTCMonth() !== month || date2.getUTCDate() !== day) return NOT_RESOLVED;
     return date2;
   }
@@ -444,7 +449,7 @@ function resolveYamlTimestamp(source) {
     while (value.length < 3) value += "0";
     fraction = +value;
   }
-  const date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
+  const date = makeUtcDate(year, month, day, hour, minute, second, fraction);
   if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month || date.getUTCDate() !== day) return NOT_RESOLVED;
   if (match[9]) {
     const offsetHour = +match[10];
@@ -542,7 +547,11 @@ var mapTag = defineMappingTag("tag:yaml.org,2002:map", {
     return Object.prototype.hasOwnProperty.call(container, String(key));
   },
   keys: (container) => Object.keys(container),
-  get: (container, key) => container[String(key)]
+  get: (container, key) => {
+    const normalizedKey = String(key);
+    if (!Object.prototype.hasOwnProperty.call(container, normalizedKey)) return null;
+    return container[normalizedKey];
+  }
 });
 var setTag = defineMappingTag("tag:yaml.org,2002:set", {
   create: () => /* @__PURE__ */ new Set(),
@@ -563,9 +572,9 @@ var setTag = defineMappingTag("tag:yaml.org,2002:set", {
 });
 function createTagDefinitionMap() {
   return {
-    scalar: {},
-    sequence: {},
-    mapping: {}
+    scalar: /* @__PURE__ */ Object.create(null),
+    sequence: /* @__PURE__ */ Object.create(null),
+    mapping: /* @__PURE__ */ Object.create(null)
   };
 }
 function createTagDefinitionListMap() {
@@ -735,7 +744,11 @@ var legacyMapTag = defineMappingTag("tag:yaml.org,2002:map", {
     return normalizedKey !== null && Object.prototype.hasOwnProperty.call(container, normalizedKey);
   },
   keys: (container) => Object.keys(container),
-  get: (container, key) => container[String(key)]
+  get: (container, key) => {
+    const normalizedKey = String(key);
+    if (!Object.prototype.hasOwnProperty.call(container, normalizedKey)) return null;
+    return container[normalizedKey];
+  }
 });
 var DEFAULT_SNIPPET_OPTIONS = {
   maxLength: 79,
@@ -1071,10 +1084,10 @@ function getScalarValue(input, scalar) {
       return getPlainValue(input, valueStart, valueEnd);
   }
 }
-var DEFAULT_TAG_HANDLERS = {
+var DEFAULT_TAG_HANDLERS = Object.assign(/* @__PURE__ */ Object.create(null), {
   "!": "!",
   "!!": "tag:yaml.org,2002:"
-};
+});
 function tagPercentEncode(source) {
   return encodeURI(source).replace(/!/g, "%21");
 }
@@ -1327,6 +1340,10 @@ function constructFromEvents(events, options) {
       }
       case 6: {
         const frame = state.frames.pop();
+        if (frame.kind === "mapping" && frame.hasKey) {
+          state.position = frame.keyPosition;
+          throwError$1(state, "incomplete mapping pair in event stream");
+        }
         if (frame.kind === "document") state.documents.push(frame.value);
         else {
           const value = frame.tag.carrierIsResult ? frame.value : finalizeCollection(state, frame.position, frame.tag, frame.value);
@@ -1997,10 +2014,6 @@ function parseNode(state, parentIndent, nodeContext, allowToSeek, allowCompact,
     else if (state.lineIndent === parentIndent) indentStatus = 0;
     else indentStatus = -1;
   }
-  if (state.position === state.lineStart && testDocumentSeparator(state)) {
-    state.depth--;
-    return false;
-  }
   if (indentStatus === 1) while (true) {
     const ch = state.input.charCodeAt(state.position);
     const propertyState = snapshotState(state);
@@ -2549,14 +2562,14 @@ function chooseScalarStyle(state, string, layout, singleLineOnly, forceQuote, in
       if (char === CHAR_LINE_FEED) {
         hasLineBreak = true;
         if (shouldTrackWidth) {
-          hasFoldableLine = hasFoldableLine || i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ";
+          hasFoldableLine = hasFoldableLine || i - previousLineBreak - 1 > lineWidth && !isMoreIndented(string[previousLineBreak + 1]);
           previousLineBreak = i;
         }
       } else if (!isPrintable(char)) return STYLE_DOUBLE;
       plain = plain && isPlainSafe(char, prevChar, inblock);
       prevChar = char;
     }
-    hasFoldableLine = hasFoldableLine || shouldTrackWidth && i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ";
+    hasFoldableLine = hasFoldableLine || shouldTrackWidth && i - previousLineBreak - 1 > lineWidth && !isMoreIndented(string[previousLineBreak + 1]);
   }
   if (!hasLineBreak && !hasFoldableLine) {
     if (plain && !forceQuote) return STYLE_PLAIN;
@@ -2621,27 +2634,30 @@ function encodeFlowBreaks(string, indent) {
 function dropEndingNewline(string) {
   return string[string.length - 1] === "\n" ? string.slice(0, -1) : string;
 }
+function isMoreIndented(char) {
+  return char === " " || char === "	";
+}
 function foldBlockScalar(string, width) {
   const lineRe = /(\n+)([^\n]*)/g;
   let nextLF = string.indexOf("\n");
   if (nextLF === -1) nextLF = string.length;
   lineRe.lastIndex = nextLF;
   let result = foldLine(string.slice(0, nextLF), width);
-  let prevMoreIndented = string[0] === "\n" || string[0] === " ";
+  let prevMoreIndented = string[0] === "\n" || isMoreIndented(string[0]);
   let moreIndented;
   let match;
   while (match = lineRe.exec(string)) {
     const prefix = match[1];
     const line = match[2];
-    moreIndented = line[0] === " ";
+    moreIndented = line !== "" && isMoreIndented(line[0]);
     result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width);
     prevMoreIndented = moreIndented;
   }
   return result;
 }
 function foldLine(line, width) {
-  if (line === "" || line[0] === " ") return line;
-  const breakRe = / [^ ]/g;
+  if (line === "" || isMoreIndented(line[0])) return line;
+  const breakRe = / [^ \t]/g;
   let match;
   let start = 0;
   let end;
@@ -2987,5 +3003,5 @@ export {
 /*! Bundled license information:
 
 js-yaml/dist/js-yaml.mjs:
-  (*! js-yaml 5.2.2 https://github.com/nodeca/js-yaml @license MIT *)
+  (*! js-yaml 5.2.3 https://github.com/nodeca/js-yaml @license MIT *)
 */

package/dist/cli-delegate/chunk-RVGBH4XK.js

@@ -0,0 +1,142 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/scripts/_lib/recycle_envelope_paths.ts
+import * as path from "node:path";
+var RECYCLE_ENVELOPE_REL = path.join("agents", "runtime", "state", "recycle-envelope.json");
+var RECYCLE_CONSUMED_REL = path.join(
+  "agents",
+  "runtime",
+  "state",
+  "recycle-envelope.consumed.json"
+);
+var RECYCLE_MAX_AGE_HOURS = 48;
+var RECYCLE_ENVELOPE_MAX_BYTES = 6144;
+
+// src/scripts/_lib/subagent_capsule.ts
+var EPISTEMIC_STATES = ["verified", "assumed", "gap"];
+var EPISTEMIC = new Set(EPISTEMIC_STATES);
+var MAX_REF_CHARS = 200;
+var MAX_LINE_CHARS = 240;
+var MAX_ENTRIES = 40;
+var CAPSULE_SCHEMA_VERSION = 2;
+function isShortLine(value, max) {
+  return typeof value === "string" && value.length > 0 && value.length <= max && !value.includes("\n");
+}
+function checkList(errors, field, value, max, required) {
+  if (value === void 0) {
+    if (required) errors.push(`${field} is required`);
+    return;
+  }
+  if (!Array.isArray(value)) {
+    errors.push(`${field} must be an array`);
+    return;
+  }
+  if (value.length > MAX_ENTRIES) {
+    errors.push(`${field} carries ${value.length} entries (max ${MAX_ENTRIES}) \u2014 a capsule is a handoff, not a transcript`);
+  }
+  const bad = value.filter((x) => !isShortLine(x, max));
+  if (bad.length > 0) {
+    errors.push(
+      `${field} carries ${bad.length} entr${bad.length === 1 ? "y" : "ies"} that are not single lines of \u2264 ${max} chars (refs and short lines only, never bodies)`
+    );
+  }
+}
+var RECYCLE_ENVELOPE_KEYS = /* @__PURE__ */ new Set([
+  "capsule_version",
+  "variant",
+  "summary",
+  "task",
+  "workspace",
+  "written_at",
+  "acceptance_criteria",
+  "remaining",
+  "not_carried_forward",
+  "decisions",
+  "constraints",
+  "open_worker_envelopes",
+  "artifact_paths",
+  "assumptions"
+]);
+function validateRecycleEnvelope(input) {
+  const errors = [];
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    return ["not an object"];
+  }
+  const e = input;
+  for (const key of Object.keys(e)) {
+    if (!RECYCLE_ENVELOPE_KEYS.has(key)) {
+      errors.push(
+        `unknown field "${key}" \u2014 a recycle envelope carries selection and pointers only; free-form additions (prose summaries included) are schema-invalid by construction`
+      );
+    }
+  }
+  if (e["capsule_version"] !== CAPSULE_SCHEMA_VERSION) {
+    errors.push(`capsule_version must be ${CAPSULE_SCHEMA_VERSION}`);
+  }
+  if (e["variant"] !== "main_session") {
+    errors.push("variant must be 'main_session'");
+  }
+  if (!isShortLine(e["summary"], MAX_LINE_CHARS)) {
+    errors.push(`summary must be a single line of 1\u2013${MAX_LINE_CHARS} chars`);
+  }
+  if (!isShortLine(e["task"], MAX_LINE_CHARS)) {
+    errors.push(`task must be a single line of 1\u2013${MAX_LINE_CHARS} chars`);
+  }
+  if (!isShortLine(e["workspace"], MAX_REF_CHARS)) {
+    errors.push(`workspace must be a path ref of \u2264 ${MAX_REF_CHARS} chars`);
+  }
+  const writtenAt = e["written_at"];
+  if (typeof writtenAt !== "string" || Number.isNaN(Date.parse(writtenAt))) {
+    errors.push("written_at must be a parseable ISO-8601 timestamp");
+  }
+  checkList(errors, "acceptance_criteria", e["acceptance_criteria"], MAX_LINE_CHARS, true);
+  if (Array.isArray(e["acceptance_criteria"]) && e["acceptance_criteria"].length === 0) {
+    errors.push('acceptance_criteria must carry at least one entry \u2014 the successor cannot know "done" without it');
+  }
+  checkList(errors, "remaining", e["remaining"], MAX_LINE_CHARS, true);
+  checkList(errors, "not_carried_forward", e["not_carried_forward"], MAX_LINE_CHARS, true);
+  checkList(errors, "decisions", e["decisions"], MAX_LINE_CHARS, false);
+  checkList(errors, "constraints", e["constraints"], MAX_LINE_CHARS, false);
+  checkList(errors, "open_worker_envelopes", e["open_worker_envelopes"], MAX_REF_CHARS, false);
+  checkList(errors, "artifact_paths", e["artifact_paths"], MAX_REF_CHARS, false);
+  const assumptions = e["assumptions"];
+  if (assumptions !== void 0) {
+    if (!Array.isArray(assumptions)) {
+      errors.push("assumptions must be an array");
+    } else {
+      if (assumptions.length > MAX_ENTRIES) {
+        errors.push(`assumptions carries ${assumptions.length} entries (max ${MAX_ENTRIES})`);
+      }
+      for (const [i, raw] of assumptions.entries()) {
+        errors.push(...validateAssumption(raw, `assumptions[${i}]`));
+      }
+    }
+  }
+  return errors;
+}
+function validateAssumption(input, label = "assumption") {
+  const errors = [];
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    return [`${label} is not an object`];
+  }
+  const a = input;
+  if (!isShortLine(a["statement"], MAX_LINE_CHARS)) {
+    errors.push(`${label}.statement must be a single line of 1\u2013${MAX_LINE_CHARS} chars`);
+  }
+  if (!isShortLine(a["basis"], MAX_REF_CHARS)) {
+    errors.push(`${label}.basis must be a ref token (file:line, id, path, command) of \u2264 ${MAX_REF_CHARS} chars`);
+  }
+  if (typeof a["epistemic_state"] !== "string" || !EPISTEMIC.has(a["epistemic_state"])) {
+    errors.push(`${label}.epistemic_state must be one of ${EPISTEMIC_STATES.join(" | ")}`);
+  }
+  return errors;
+}
+
+export {
+  RECYCLE_ENVELOPE_REL,
+  RECYCLE_CONSUMED_REL,
+  RECYCLE_MAX_AGE_HOURS,
+  RECYCLE_ENVELOPE_MAX_BYTES,
+  CAPSULE_SCHEMA_VERSION,
+  validateRecycleEnvelope
+};