@event4u/agent-config 9.29.0 → 9.31.0

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
+};

package/dist/cli-delegate/{chunk-MMXA5GY7.js → chunk-UVKNIJH2.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). No fire rate is quoted here on purpose: the measured rate moved twice while the instrument itself was being corrected, so a number in a shipped description would be a moving target. Re-derive it with `measure-turn-end-gate --store <transcript dir>` against your own corpus before arming the gate. 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 reply is not in the pinned language (19 measured occurrences). Fenced code, inline code, quoted tool output, tables, URLs and paths are stripped first, and the remainder is then scored LEAD-FIRST by the same classifier that sets the pin \u2014 so the verdict usually comes from the reply opening, not from all of it. Sharing that classifier is deliberate: it stops the pin and the detector disagreeing about a turn. Accepted opt-in spellings for the switches below include YAML true/false and yes/no/on/off. Inert while hooks.turn_end_gate.enabled is false."
+      )
     }).default({})
   }),
   decision_engine: external_exports.object({

package/dist/cli-delegate/cmd_analyze_session.js

@@ -7,7 +7,7 @@ import {
 import {
   ProjectRootError,
   resolve_project_root
-} from "./chunk-LCFJIQ4J.js";
+} from "./chunk-JEJABGKB.js";
 import "./chunk-NDJLNC6Q.js";
 import "./chunk-J55WI3RR.js";
 

package/dist/cli-delegate/cmd_brand_status.js

@@ -1,7 +1,7 @@
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
 import {
   resolve_project_root
-} from "./chunk-LCFJIQ4J.js";
+} from "./chunk-JEJABGKB.js";
 import "./chunk-NDJLNC6Q.js";
 import "./chunk-J55WI3RR.js";