@event4u/agent-config 16.2.0 → 16.4.0

package/dist/agent-src/templates/scripts/work_engine/directives/ui/apply.ts

@@ -133,12 +133,11 @@ export function run(state: DeliveryState): StepResult {
             return _halt_coverage(state, provided, report.gaps);
         }
         notes.push(...report.fallbacks);
-        // 3.1 — reported in shadow: the outcome value is unchanged for one
-        // release, so a caller branching on it is found by the line rather
-        // than by the breakage.
-        const handed_back = _handed_back_line(report);
-        if (handed_back !== null) {
-            notes.push(handed_back);
+        // 3.2 — the shadow is now the outcome. 3.1 shipped the line one
+        // release ahead (16.2.0 carries it) so a caller branching on
+        // `SUCCESS` was found by the words before it is found by the value.
+        if (carried_nothing(report)) {
+            return _halt_carried_nothing(state, report, notes);
         }
     }
 
@@ -390,6 +389,49 @@ function _halt_coverage(
     });
 }
 
+/**
+ * BLOCKED halt — the port accounted for everything and carried none of it.
+ *
+ * The gap list is empty here by construction: a complete report and a complete
+ * surrender look identical to `coverage_gaps`, which is why this is its own
+ * halt rather than a gap. `questions` is non-empty because the dispatcher
+ * rejects a `BLOCKED` result that surfaces nothing to answer — handing the
+ * work back has to come with a way forward, not just a refusal.
+ */
+function _halt_carried_nothing(
+    state: DeliveryState,
+    report: CoverageReport,
+    fallbacks: ReadonlyArray<string>,
+): StepResult {
+    const directive = _resolve_directive(state);
+    const lines: string[] = [
+        agent_directive(directive),
+        '> Apply rejected: the coverage report accounts for every declared ' +
+            'item and the port carried none of them over.',
+        `> All ${report.declared.length} declared item(s) are in \`flagged\`:`,
+    ];
+    for (const item of report.handed_back) {
+        lines.push(`> - \`${item}\``);
+    }
+    lines.push(
+        '> A complete report and a complete hand-back are the same empty gap ' +
+            'list, so this is checked separately — flagging one handler the ' +
+            'port could not carry is the ledger working; flagging all of them ' +
+            'is the port not having run.',
+        '> 1. Continue — implement the items above and re-write ' +
+            '`ui_apply.coverage` with each one in `honoured` or `translated`, ' +
+            'leaving in `flagged` only what genuinely could not be carried',
+        '> 2. Flag deliberately — say here which of the items above are out of ' +
+            'scope for this port and why, and the operator decides',
+        '> 3. Abort — drop this UI request',
+    );
+    return new StepResult({
+        outcome: Outcome.BLOCKED,
+        questions: lines,
+        message: [...fallbacks, `UI apply rejected: ${_handed_back_line(report)}`].join('\n'),
+    });
+}
+
 /** Return the agent-written `ui_apply` envelope, or `null`. */
 function _apply_envelope(state: DeliveryState): Record<string, Any> | null {
     const data = _pyTruthy(state.ticket) ? state.ticket : {};

package/dist/agent-src/templates/scripts/work_engine/hooks/builtin/decision_trace.ts

@@ -3,8 +3,9 @@
  *
  * TypeScript twin of `work_engine/hooks/builtin/decision_trace.py` (ADR-200
  * py2ts — work_engine.hooks.builtin subpackage). Implements the v1 envelope
- * from `docs/contracts/decision-trace-v1.md`. Default-off; opt-in via
- * `.agent-settings.yml` `decision_engine.surface_traces: true`.
+ * from `docs/contracts/decision-trace-v1.md`. Off: the settings key that
+ * registered it was retired, so only a caller that builds the registry
+ * directly enables it.
  *
  * The hook is purely observational — it never mutates `DeliveryState`, never
  * raises terminal errors. Stream / disk failures surface as {@link HookError}

package/dist/agent-src/templates/scripts/work_engine/hooks/builtin/memory_visibility.ts

@@ -31,7 +31,8 @@ type Any = unknown;
 /**
  * Thread the `🧠 Memory: <hits>/<asks> · ids=[…]` line into the report.
  *
- * `memory_cadence` is the `memory.cadence` cadence key. `visibility_off`
+ * `memory_cadence` is the cadence the hook was built with; settings always
+ * yield `always` since the `memory.cadence` key was retired. `visibility_off`
  * mirrors `memory.visibility: off`. `asked_types` overrides the list of
  * memory types treated as `asks` in the visibility line.
  */

package/dist/agent-src/templates/scripts/work_engine/hooks/settings.ts

@@ -157,7 +157,6 @@ function _settings_from_raw(data: SettingsDict): HookSettings {
 
     const memory_section = data['memory'];
     let visibility_off = false;
-    let memory_cadence = 'always';
     if (_isPlainDict(memory_section)) {
         const ms = memory_section as Record<string, Any>;
         const rawVis = ms['visibility'];
@@ -166,10 +165,6 @@ function _settings_from_raw(data: SettingsDict): HookSettings {
         } else if (typeof rawVis === 'boolean' && rawVis === false) {
             visibility_off = true;
         }
-        const cadence_raw = ms['cadence'];
-        if (cadence_raw !== null && cadence_raw !== undefined) {
-            memory_cadence = String(cadence_raw).trim().toLowerCase() || 'always';
-        }
     }
 
     const memory_hooks = hooksDict['memory_visibility'];
@@ -192,7 +187,6 @@ function _settings_from_raw(data: SettingsDict): HookSettings {
         decision_trace: decision_trace_on,
         memory_visibility: memory_visibility_on,
         memory_visibility_off: visibility_off,
-        memory_cadence,
         chat_history_enabled: chat_block_enabled && global_chat_on,
         chat_history_script: chat_script,
         decision_engine: decision_engine_settings,

package/dist/agent-src/templates/scripts/work_engine/scoring/decision_engine.ts

@@ -11,9 +11,10 @@
  *
  * Schema (all keys optional; the parser rejects unknown keys hard):
  *
- * - `surface_traces` (bool, default `false`) — opt-in for
- *   `DecisionTraceHook`. Predates the gates; lives here so the
- *   `decision_engine:` block has one source-of-truth schema.
+ * - `surface_traces` — RETIRED, accepted and ignored. The trace hook stays
+ *   off (the old default). Still in `ALLOWED_KEYS` so a block that carries
+ *   the leftover key is not rejected wholesale, which would drop the gates
+ *   it configures alongside it.
  * - `min_confidence` (`low`/`medium`/`high`/`off`, default
  *   `off`) — confidence-band floor; Phase=Plan refuses to advance
  *   when the band is below.
@@ -27,8 +28,9 @@
  * - `ask_timeout_seconds` (int, default `30`) — timeout when
  *   `on_block=ask` runs in a non-interactive context (no TTY, or
  *   `CI=true`).
- * - `on_block_fallback` (`stop`/`warn`, default `stop`) —
- *   resolution after `ask_timeout` elapses.
+ * - `on_block_fallback` — RETIRED, accepted and ignored for the same
+ *   reason; the resolution after `ask_timeout` is always `stop`, the
+ *   fail-safe value.
  *
  * Gate-conflict resolution (first match wins, only one gate fires per
  * phase):
@@ -57,7 +59,6 @@ export const ALLOWED_KEYS: ReadonlySet<string> = new Set([
 const _LEVEL_VALUES: ReadonlySet<string> = new Set(['low', 'medium', 'high', 'off']);
 const _LEVEL_RANK: Record<string, number> = { low: 1, medium: 2, high: 3 };
 const _ON_BLOCK_VALUES: ReadonlySet<string> = new Set(['stop', 'ask', 'warn']);
-const _FALLBACK_VALUES: ReadonlySet<string> = new Set(['stop', 'warn']);
 
 /**
  * Conflict-resolution order. Highest-impact gate first; the first
@@ -177,17 +178,13 @@ export function parse(data: Any): DecisionEngineSettings {
         );
     }
     return new DecisionEngineSettings({
-        surface_traces: _coerce_bool(_get(d, 'surface_traces', undefined), false),
+        surface_traces: false,
         min_confidence: _coerce_level(_get(d, 'min_confidence', 'off'), 'min_confidence'),
         block_on_risk: _coerce_level(_get(d, 'block_on_risk', 'off'), 'block_on_risk'),
         require_memory_hits: _coerce_bool(_get(d, 'require_memory_hits', undefined), false),
         on_block: _coerce_choice(_get(d, 'on_block', 'stop'), 'on_block', _ON_BLOCK_VALUES),
         ask_timeout_seconds: _coerce_int(_get(d, 'ask_timeout_seconds', 30), 'ask_timeout_seconds'),
-        on_block_fallback: _coerce_choice(
-            _get(d, 'on_block_fallback', 'stop'),
-            'on_block_fallback',
-            _FALLBACK_VALUES,
-        ),
+        on_block_fallback: 'stop',
     });
 }
 

package/dist/agent-src/templates/scripts/work_engine/scoring/memory_visibility.ts

@@ -284,7 +284,8 @@ export function format_changed_decisions_block(
 /**
  * Apply the cadence + opt-out gates from the contract.
  *
- * `memory_cadence` is the `memory.cadence` cadence key:
+ * `memory_cadence` is the cadence the hook was built with (the
+ * `memory.cadence` settings key is retired; settings always yield `always`):
  *
  *   - `always` (default) — emit whenever `asks >= 1`.
  *   - `auto` — emit only when `asks >= 3` (reduces noise on