@event4u/agent-config 15.0.0 → 16.0.0

package/dist/agent-src/commands/roadmap/create.md

@@ -272,8 +272,9 @@ Ask (in the user's language) exactly one numbered-options question:
 
 > How should this roadmap be executed later?
 >
-> 1. Fully autonomous — one run-start contract confirmation, then no
->    interruptions except the safety floors
+> 1. Fully autonomous — one run-start contract confirmation, then the
+>    only halts are the safety floors, a quality-red, and a step that
+>    reveals out-of-roadmap work
 > 2. Checkpoint at phase boundaries — compact status + continue prompt
 >    per phase
 > 3. Interactive — every gate fires as today

package/dist/agent-src/contexts/communication/rules-auto/user-interaction-mechanics.md

@@ -202,3 +202,53 @@ After completing a batch of actions, provide a summary table:
 | 2 | `test.php` | Updated assertion |
 | 3 | `config.php` | Skipped (intentional) |
 ```
+
+## The trigger is a decision, not a format — the measurement behind it
+
+Migrated out of `user-interaction.md` on 2026-09-11 to pay for Iron Law 3
+under the per-spawn preamble budget. The obligation stays in the rule; this
+is the evidence for it.
+
+Measured (30-session conformance audit, 2026-08-06): **every** malformed ask
+was a one-line parenthetical or a trailing free-text offer — a German
+"say the word if I should take the three lines along", an English "shall I
+implement it this way?" — while the same sessions formatted their **large**
+asks perfectly. So the rule is being read as *if numbered options, then a
+recommendation line*. It is the other way round, and an ask that feels too
+small for a block is exactly the one that escapes the format.
+
+Three further caught shapes: a contentless filler option; an inline
+"(recommended)" tag **beside** the recommendation line (the dual source
+Iron Law 1 forbids); an option set answerable only as `1,3,4`.
+
+**No gate ships for this.** `check_reply_consistency` can read a draft on
+stdin, but it inspects *numbered-option blocks* — and every measured failure
+had no block by construction, so it scans exactly the surface that did not
+fail. `conformance:behavior` deliberately does not score ask-shape, so an
+unmoved rate is a finding rather than a silence.
+
+## Iron Law 3 — why laws 1 and 2 do not reach across a turn boundary
+
+Iron Laws 1 and 2 are discharged by the shape of the reply that carries the
+block. Neither survives a turn boundary, which is the gap Iron Law 3 closes:
+a second assistant execution with no user message between it and the ask is
+not a new conversation, and from the user's side a thread that ends without
+the question ended without the question.
+
+**The measured failure.** A turn put three numbered options and a
+recommendation line to the user. A `stop` concern then produced a second
+assistant execution with no intervening user message, and that second reply
+handled the concern while demoting the open question to a subordinate clause.
+The four rules that could have caught it did not, each for a stated reason:
+Iron Law 1 inspects a reply that HAS an options block, `check_reply_consistency`
+receives a draft rather than a transcript, `active-remediation` governs
+findings rather than issued decisions, and `no-cheap-questions` guards the
+opposite direction.
+
+**Carrier, stated honestly.** The deterministic half is the
+`pending-decision` detector in `src/scripts/hooks/turn_end_gate_hook.ts` —
+it refuses a turn-end when an earlier reply in the same user turn carried a
+block and the closing reply carries none. It sees one user turn on one host,
+so everything outside that is model-carried, exactly like Iron Law 2's own
+"no gate ships for this" note. `check_reply_consistency` reads a single draft
+and holds no cross-turn state; it cannot see this law at all.

package/dist/agent-src/rules/user-interaction.md

@@ -19,9 +19,10 @@ obligation_frequency: "per-turn"
 
 # User Interaction
 
-Two Iron Laws govern every reply that contains numbered options.
-They override conversation momentum, brevity, and the urge to defer
-to the user. **Missing a recommendation is a rule violation, not a slip.**
+Three Iron Laws govern a decision put to the user — two on the reply that
+carries it, one on what happens if the agent runs again before the answer.
+They override conversation momentum, brevity, and the urge to defer to the
+user. **Missing a recommendation is a rule violation, not a slip.**
 
 ## Iron Law 1 — Single-Source Recommendation
 
@@ -43,14 +44,28 @@ EVERY REPLY WITH NUMBERED OPTIONS RUNS THE SELF-CHECK. NO EXCEPTIONS.
 SKIPPING IT IS A RULE VIOLATION, NOT A SLIP.
 ```
 
-Mechanical backstop:
+Mechanical backstop for Iron Laws 1 and 2 (non-zero exit on either), a safety
+net under the self-scan rather than a replacement for it:
 `./scripts-run src/scripts/check_reply_consistency --stdin < draft.md`
-(non-zero exit on any rule below). Self-scan is the primary gate;
-the script is the deterministic safety net.
+It takes a DRAFT, so it cannot see Iron Law 3, which is about a transcript.
+
+## Iron Law 3 — A Decision Outlives the Turn
+
+```
+A DECISION HANDED TO THE USER STAYS LIVE UNTIL THE USER ANSWERS IT.
+THE AGENT RUNS AGAIN WITHOUT AN ANSWER — HOOK CONTINUATION, NOTIFICATION,
+WAKE, RETRY — AND THE BLOCK PLUS ITS RECOMMENDATION LINE ARE RE-PRESENTED
+IN THE SAME FORM. A SUBORDINATE CLAUSE IS NOT A RE-PRESENTATION.
+A HOOK'S CONCERN MAY BE ADDED TO A PENDING DECISION, NEVER REPLACE ONE.
+ONLY THE USER CLOSES IT — BY ANSWERING, OR BY MAKING IT MOOT.
+```
+
+Carrier: the `pending-decision` detector on `turn-end-gate`, one user turn on
+one host; the rest is model-carried. Mechanics carries the measured failure.
 
 ## Question pacing — one decision point per turn
 
-[`ask-when-uncertain`](ask-when-uncertain.md)'s Iron Law is canonical: **one question per turn**. What counts as "one question" is **one decision point** — a single numbered-options block is ONE question even when its options span multiple dimensions (a depth-and-framework matrix answered with a single number is one decision). Multiple separate asks in one reply, or a block whose answer would need a structured reply (`1a, 2b`), violate the kernel rule's self-check.
+[`ask-when-uncertain`](ask-when-uncertain.md)'s Iron Law is canonical: **one question per turn**. What counts as "one question" is **one decision point** — one numbered-options block is ONE question even when its options span several dimensions, provided a single number answers it. Multiple separate asks in one reply, or a block needing a structured reply (`1a, 2b`), violate the kernel rule's self-check.
 
 If in doubt, split into serial turns — never a long batched prompt.
 
@@ -62,33 +77,19 @@ NOT ON THE PRESENCE OF A NUMBERED LIST.
 A TRAILING FREE-TEXT OFFER IS AN ASK. A BARE YES/NO IS AN ASK.
 ```
 
-Measured (30-session conformance audit, 2026-08-06): **every** malformed ask was
-a one-line parenthetical or a trailing free-text offer — *"sag Bescheid, wenn
-ich die drei Zeilen mitnehmen soll"*, *"Soll ich das so umsetzen?"* — while the
-same sessions formatted their **large** asks perfectly. So the rule is being
-read as *if numbered options, then a recommendation line*. It is the other way
-round, and an ask that feels too small for a block is exactly the one that
-escapes the format. Three further caught shapes: a contentless filler option; an
-inline `(Empfohlen)` tag **beside** the recommendation line (the dual source
-Iron Law 1 forbids); an option set answerable only as `1,3,4`.
-
-**No gate ships for this.** `check_reply_consistency` can read a draft on stdin,
-but it inspects *numbered-option blocks* — and every measured failure had no
-block by construction, so it scans exactly the surface that did not fail. `conformance:behavior` deliberately does not score ask-shape,
-so an unmoved rate is a finding rather than a silence.
+Measured (30-session audit, 2026-08-06): **every** malformed ask was a one-line
+parenthetical or a trailing offer, while the same sessions formatted their
+**large** asks perfectly — the ask that feels too small for a block is the one
+that escapes the format. **No gate ships for this**: the backstop inspects
+numbered-option blocks, and every measured failure had none. Detail: mechanics.
 
 ## Mechanics — rationale, failure modes, format details, examples
 
-The "why take a position", position-agnostic clause, format
-specification (neutral block + bolded recommendation line + caveat),
-no-trailing-open-question rule, "what does NOT count" catalog, full
-five-step pre-send self-check, named failure-mode catalog (end-of-turn
-menu, trailing-question hedge, no-preference hedge, multi-block reply,
-…), slip-handling protocol, numbered-options rules, format examples,
-progress indicators, and summary-table patterns all live in
+The rule above is the obligation surface. Everything you look up rather than
+obey — why to take a position, the format spec, the five-step self-check, the
+named failure-mode catalog, slip handling, examples, progress indicators and
+summary patterns — is in
 [`contexts/communication/rules-auto/user-interaction-mechanics.md`](../contexts/communication/rules-auto/user-interaction-mechanics.md).
-The rule above is the obligation surface; the mechanics file is the
-lookup material.
 
 When the user pastes large tool output, logs, JSON, or API responses,
 keep the reply narrow: extract only the relevant fields with targeted

package/dist/agent-src/skills/error-handling-patterns/SKILL.md

@@ -79,6 +79,15 @@ Every produced error must carry: `code` (stable string), `message` (human-readab
 
 Forbidden: secrets, raw SQL, full stack traces in user-facing surfaces, internal class names leaked through API boundaries.
 
+**"User-facing" means PRODUCTION, and the missing half of that sentence cost a real failure.** Read without the qualifier — as it stood until 2026-09-11 — this clause forbids the developer's own diagnostics in their own dev environment, which is the opposite of what it is for. The measured consequence, reported by the maintainer: a feature whose detail view crashed on open and showed a blank region, so neither the developer nor the agent could see *what* was missing, and the failure had to be reconstructed by hand.
+
+| Environment | What a failed render or request shows |
+|---|---|
+| local / dev / preview | the **full** diagnostic, visibly: what was expected, what arrived, which field or endpoint, the stack. A toast, an error overlay, an inline panel — anything the developer cannot miss. Silence here is the defect. |
+| production | the sanitized payload above, plus a correlation id the developer can look up. Never the stack. |
+
+**A blank page is never an acceptable failure mode in dev.** If a component cannot render because data is missing or a contract changed, it says so on screen in dev and degrades to a stated empty/error state in production — never to nothing. That is the same obligation the four completeness rows in [`ai-code-blindspots`](../ai-code-blindspots/SKILL.md) put on the render surface, stated here for the error path that reaches it.
+
 ### Step 5 — Define the boundary
 
 Exactly **one** layer translates internal errors to the egress format (HTTP status + body, queue requeue policy, CLI exit code). Anywhere else doing this duplication is the bug.

package/dist/agent-src/templates/agents/agent-project-settings.example.yml

@@ -39,7 +39,7 @@ schema_version: 1
 # CI guard: a release bump of `package.json` must update this value
 # in lockstep — see scripts/check_template_pin_drift.ts (road-to-
 # portable-runtime-and-update-check P3.3).
-agent_config_version: "15.0.0"
+agent_config_version: "16.0.0"
 
 # --- Project identity ---
 project:

package/dist/cli-delegate/{chunk-HZ52BRGG.js → chunk-H32DGUJH.js}

@@ -1,90 +1,16 @@
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  artefact_roots
+} from "./chunk-NUHLI2RX.js";
 import {
   DEFAULT_PROJECT_FILE,
   logger
 } from "./chunk-2XY7ILBT.js";
 
 // src/scripts/config/profiles.ts
-import * as fs2 from "node:fs";
-import { createRequire } from "node:module";
-import * as path3 from "node:path";
-
-// src/scripts/_lib/agent_src.ts
 import * as fs from "node:fs";
-import * as path2 from "node:path";
-import { fileURLToPath } from "node:url";
-
-// src/scripts/_lib/guidelines_lane.ts
+import { createRequire } from "node:module";
 import * as path from "node:path";
-var GUIDELINES_SOURCE_REL = path.join("docs", "guidelines");
-
-// src/scripts/_lib/agent_src.ts
-var _HERE = path2.dirname(fileURLToPath(import.meta.url));
-var _DEFAULT_ROOT = path2.resolve(_HERE, "..", "..", "..");
-function _deriveRoots(root) {
-  const packages = path2.join(root, "packages");
-  const src = path2.join(root, "src");
-  return {
-    ROOT: root,
-    LEGACY_SRC: path2.join(root, ".agent-src.uncondensed"),
-    PACKAGES: packages,
-    PACKAGE_CORE: path2.join(packages, "core"),
-    SRC: src,
-    SRC_SKILLS: path2.join(src, "skills"),
-    SRC_RULES: path2.join(src, "rules"),
-    SRC_AGENT: path2.join(src, "agent-src"),
-    SRC_DOMAINS: path2.join(src, "domains")
-  };
-}
-var _roots = _deriveRoots(_DEFAULT_ROOT);
-function _isDir(p) {
-  try {
-    return fs.statSync(p).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function _exists(p) {
-  try {
-    fs.statSync(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function _iterdirSorted(p) {
-  let names;
-  try {
-    names = fs.readdirSync(p);
-  } catch {
-    return [];
-  }
-  names.sort();
-  return names.map((name) => path2.join(p, name));
-}
-function artefact_roots() {
-  const roots = [];
-  if (_exists(_roots.LEGACY_SRC)) {
-    roots.push(_roots.LEGACY_SRC);
-  }
-  if (_exists(_roots.PACKAGES)) {
-    for (const pkg of _iterdirSorted(_roots.PACKAGES)) {
-      const sub = path2.join(pkg, ".agent-src.uncondensed");
-      if (_isDir(sub)) {
-        roots.push(sub);
-      }
-    }
-  }
-  if (_isDir(_roots.SRC_AGENT)) {
-    roots.push(_roots.SRC_AGENT);
-  }
-  if (_isDir(_roots.SRC_SKILLS) || _isDir(_roots.SRC_RULES)) {
-    roots.push(_roots.SRC);
-  }
-  return roots;
-}
-
-// src/scripts/config/profiles.ts
 var _require = createRequire(import.meta.url);
 var PROFILE_ID_ENV = "AGENT_CONFIG_PROFILE_ID";
 var DEFAULT_PROFILE_ID = "developer";
@@ -135,7 +61,7 @@ function _load_yaml(p) {
   }
   let text;
   try {
-    text = fs2.readFileSync(p, "utf-8");
+    text = fs.readFileSync(p, "utf-8");
   } catch (exc) {
     logger.warning("profile read failed for %s: %s", p, String(exc));
     return {};
@@ -153,8 +79,8 @@ function _load_yaml(p) {
   return _isPlainDict(data) ? data : {};
 }
 function profile_file(project_root, profile_id) {
-  const legacy = path3.join(project_root, PROFILES_DIRNAME, `${profile_id}.yml`);
-  if (_exists2(legacy)) {
+  const legacy = path.join(project_root, PROFILES_DIRNAME, `${profile_id}.yml`);
+  if (_exists(legacy)) {
     return legacy;
   }
   let roots;
@@ -164,8 +90,8 @@ function profile_file(project_root, profile_id) {
     return legacy;
   }
   for (const root of roots) {
-    const candidate = path3.join(root, "profiles", `${profile_id}.yml`);
-    if (_exists2(candidate)) {
+    const candidate = path.join(root, "profiles", `${profile_id}.yml`);
+    if (_exists(candidate)) {
       return candidate;
     }
   }
@@ -217,14 +143,14 @@ function _pick_id(pack_profile_id, user_settings, runtime_id) {
 }
 function resolve_profile(params) {
   const settings = params.user_settings ?? {};
-  const settings_file = path3.join(params.project_root, DEFAULT_PROJECT_FILE);
+  const settings_file = path.join(params.project_root, DEFAULT_PROJECT_FILE);
   const [profile_id, source] = _pick_id(
     params.pack_profile_id ?? null,
     settings,
     params.runtime_id ?? null
   );
   if (profile_id === null) {
-    if (_exists2(settings_file)) {
+    if (_exists(settings_file)) {
       return new ResolvedProfile({
         id: DEFAULT_PROFILE_ID,
         source: SOURCE_MISSING,
@@ -238,16 +164,16 @@ function resolve_profile(params) {
     );
   }
   const yaml_path = profile_file(params.project_root, profile_id);
-  if (!_exists2(yaml_path)) {
+  if (!_exists(yaml_path)) {
     throw new ProfileError(
       `profile.id=${_repr(profile_id)} (${source}) but ${yaml_path} not found`
     );
   }
   return _build_resolved(profile_id, _load_yaml(yaml_path), { source });
 }
-function _exists2(p) {
+function _exists(p) {
   try {
-    fs2.statSync(p);
+    fs.statSync(p);
     return true;
   } catch {
     return false;
@@ -267,7 +193,6 @@ function _repr(s) {
 }
 
 export {
-  artefact_roots,
   PROFILE_ID_ENV,
   SOURCE_MISSING,
   ProfileError,

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

@@ -0,0 +1,80 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/scripts/_lib/agent_src.ts
+import * as fs from "node:fs";
+import * as path2 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/scripts/_lib/guidelines_lane.ts
+import * as path from "node:path";
+var GUIDELINES_SOURCE_REL = path.join("docs", "guidelines");
+
+// src/scripts/_lib/agent_src.ts
+var _HERE = path2.dirname(fileURLToPath(import.meta.url));
+var _DEFAULT_ROOT = path2.resolve(_HERE, "..", "..", "..");
+function _deriveRoots(root) {
+  const packages = path2.join(root, "packages");
+  const src = path2.join(root, "src");
+  return {
+    ROOT: root,
+    LEGACY_SRC: path2.join(root, ".agent-src.uncondensed"),
+    PACKAGES: packages,
+    PACKAGE_CORE: path2.join(packages, "core"),
+    SRC: src,
+    SRC_SKILLS: path2.join(src, "skills"),
+    SRC_RULES: path2.join(src, "rules"),
+    SRC_AGENT: path2.join(src, "agent-src"),
+    SRC_DOMAINS: path2.join(src, "domains")
+  };
+}
+var _roots = _deriveRoots(_DEFAULT_ROOT);
+function _isDir(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function _exists(p) {
+  try {
+    fs.statSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function _iterdirSorted(p) {
+  let names;
+  try {
+    names = fs.readdirSync(p);
+  } catch {
+    return [];
+  }
+  names.sort();
+  return names.map((name) => path2.join(p, name));
+}
+function artefact_roots() {
+  const roots = [];
+  if (_exists(_roots.LEGACY_SRC)) {
+    roots.push(_roots.LEGACY_SRC);
+  }
+  if (_exists(_roots.PACKAGES)) {
+    for (const pkg of _iterdirSorted(_roots.PACKAGES)) {
+      const sub = path2.join(pkg, ".agent-src.uncondensed");
+      if (_isDir(sub)) {
+        roots.push(sub);
+      }
+    }
+  }
+  if (_isDir(_roots.SRC_AGENT)) {
+    roots.push(_roots.SRC_AGENT);
+  }
+  if (_isDir(_roots.SRC_SKILLS) || _isDir(_roots.SRC_RULES)) {
+    roots.push(_roots.SRC);
+  }
+  return roots;
+}
+
+export {
+  artefact_roots
+};

package/dist/cli-delegate/{chunk-TYSY33MD.js → chunk-QJWAUMJW.js}

@@ -891,7 +891,9 @@ var DETECTOR_IDS = [
   "promissory",
   "language",
   "verification",
-  "completion"
+  "completion",
+  "pending-decision",
+  "untested"
 ];
 var REFUSAL_STATE_REL = path2.join("agents", "runtime", "state", "turn-end-gate");
 function refusalStateDir(workspaceRoot) {
@@ -916,7 +918,9 @@ function readSessionCounts(workspaceRoot, sessionId) {
   }
 }
 function emptyCounts() {
-  return { promissory: 0, language: 0, verification: 0, completion: 0 };
+  const out = {};
+  for (const id of DETECTOR_IDS) out[id] = 0;
+  return out;
 }
 function isDetector(v) {
   return typeof v === "string" && DETECTOR_IDS.includes(v);
@@ -942,6 +946,9 @@ function parseRecord(raw) {
   if (typeof o["agent_config_version"] === "string") {
     rec.agent_config_version = o["agent_config_version"];
   }
+  if (typeof o["refused_prompt_id"] === "string") {
+    rec.refused_prompt_id = o["refused_prompt_id"];
+  }
   const counts = o["counts"];
   if (typeof counts === "object" && counts !== null && !Array.isArray(counts)) {
     const parsed = {};
@@ -985,6 +992,9 @@ function foldRefusal(prev, input) {
   else if (prev?.agent_config_version !== void 0) {
     rec.agent_config_version = prev.agent_config_version;
   }
+  if (input.promptId !== void 0 && input.promptId !== "") {
+    rec.refused_prompt_id = input.promptId;
+  }
   return rec;
 }
 function readInstallBoundary() {

package/dist/cli-delegate/{chunk-2KKXJW25.js → chunk-S3VFXMTM.js}

@@ -3,7 +3,7 @@ import {
   pruneAgedRefusalState,
   readSessionCounts,
   statePathFor
-} from "./chunk-TYSY33MD.js";
+} from "./chunk-QJWAUMJW.js";
 import {
   readHookStdin
 } from "./chunk-F7DQWYR5.js";