@event4u/agent-config 9.9.0 → 9.11.0

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

@@ -15,6 +15,11 @@ import {
     StepResult,
     agent_directive,
 } from '../../delivery_state.js';
+import {
+    UNSUPPORTED_LANE,
+    bundle_line,
+    unsupported_stack_questions,
+} from './stack_bundles.js';
 
 /** Maximum number of polish rounds per `/work` run. */
 export const POLISH_CEILING = 2;
@@ -31,9 +36,15 @@ export const TOKEN_REPEAT_THRESHOLD = 2;
 /** Map `state.stack.frontend` → agent-directive skill name. */
 export const STACK_DIRECTIVES: Record<string, string> = {
     'blade-livewire-flux': 'ui-polish-blade-livewire-flux',
+    'blade-livewire': 'ui-polish-blade-livewire',
+    filament: 'ui-polish-filament',
     'react-shadcn': 'ui-polish-react-shadcn',
+    react: 'ui-polish-react',
     vue: 'ui-polish-vue',
     plain: 'ui-polish-plain',
+    // Present so the `keys == KNOWN_STACKS` invariant holds. Never emitted —
+    // the step intercepts this lane and refuses instead of dispatching.
+    unknown: 'ui-polish-unsupported',
 };
 
 /** Fallback directive when `state.stack` is missing or malformed. */
@@ -184,6 +195,14 @@ function _delegate_to_polish_skill(
     ceiling: number,
 ): StepResult {
     const directive = _resolve_directive(state);
+    const unsupported_label = _stack_label(state);
+    if (unsupported_label === UNSUPPORTED_LANE) {
+        return new StepResult({
+            outcome: Outcome.BLOCKED,
+            questions: unsupported_stack_questions('polish'),
+            message: 'UI polish refused: frontend framework not modelled by any lane.',
+        });
+    }
     const stack_label = _stack_label(state);
     const next_round = rounds + 1;
     let findings_line =
@@ -203,6 +222,7 @@ function _delegate_to_polish_skill(
         questions: [
             agent_directive(directive),
             `> Stack: \`${stack_label}\`. Polish round ${next_round} of ${ceiling}.`,
+            bundle_line(stack_label, 'build'),
             findings_line,
             '> Fix chart-type / contrast findings against the adopted ' +
                 "corpus rows (design-intelligence § 'Grounding the " +
@@ -336,7 +356,7 @@ function _classify_token_violations(
     tokens: Record<string, Any>,
 ): [Record<string, Any>[], Record<string, Any>[]] {
     const matched: Record<string, Any>[] = [];
-    // Insertion-ordered map keyed by `${category}${value}` to mirror the
+    // Insertion-ordered map keyed by `${category}\0${value}` to mirror the
     // Python `dict[tuple[str, str], int]` insertion order.
     const unmatched_counts = new Map<string, { category: string; value: string; count: number }>();
     for (const finding of findings) {
@@ -356,7 +376,7 @@ function _classify_token_violations(
             matched.push(finding);
             continue;
         }
-        const key = `${category}${value}`;
+        const key = `${category}\0${value}`;
         const existing = unmatched_counts.get(key);
         if (existing) {
             existing.count += 1;

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

@@ -16,13 +16,24 @@ import {
     StepResult,
     agent_directive,
 } from '../../delivery_state.js';
+import {
+    UNSUPPORTED_LANE,
+    bundle_line,
+    unsupported_stack_questions,
+} from './stack_bundles.js';
 
-/** Map `state.stack.frontend` → agent-directive skill name. */
+/** Map `state.stack.frontend` → agent-directive verb. */
 export const STACK_DIRECTIVES: Record<string, string> = {
     'blade-livewire-flux': 'ui-design-review-blade-livewire-flux',
+    'blade-livewire': 'ui-design-review-blade-livewire',
+    filament: 'ui-design-review-filament',
     'react-shadcn': 'ui-design-review-react-shadcn',
+    react: 'ui-design-review-react',
     vue: 'ui-design-review-vue',
     plain: 'ui-design-review-plain',
+    // Present so the `keys == KNOWN_STACKS` invariant holds. Never emitted —
+    // the step intercepts this lane and refuses instead of dispatching.
+    unknown: 'ui-design-review-unsupported',
 };
 
 /** Fallback directive when `state.stack` is missing or malformed. */
@@ -181,12 +192,20 @@ function _stack_label(state: DeliveryState): string {
 function _delegate_to_review_skill(state: DeliveryState): StepResult {
     const directive = _resolve_directive(state);
     const stack_label = _stack_label(state);
+    if (stack_label === UNSUPPORTED_LANE) {
+        return new StepResult({
+            outcome: Outcome.BLOCKED,
+            questions: unsupported_stack_questions('review'),
+            message: 'UI review refused: frontend framework not modelled by any lane.',
+        });
+    }
     return new StepResult({
         outcome: Outcome.BLOCKED,
         questions: [
             agent_directive(directive),
             `> Stack: \`${stack_label}\`. Reviewing rendered components ` +
                 'against the locked design brief.',
+            bundle_line(stack_label, 'review'),
             '> The review pass compares `state.ticket.ui_apply.rendered` ' +
                 'against `state.ui_design` (microcopy, states, a11y, layout) ' +
                 'and produces a structured `findings` list.',
@@ -294,7 +313,7 @@ function _filter_known(violations: Any[], known: Any[]): Any[] {
  * scalars, mirroring Python tuple-equality in a JS `Set`.
  */
 function _keyOf(rule: Any, selector: Any): string {
-    return `${_tag(rule)}${_tag(selector)}`;
+    return `${_tag(rule)}\0${_tag(selector)}`;
 }
 
 function _tag(v: Any): string {

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

@@ -0,0 +1,179 @@
+/**
+ * Verb → skill-bundle map for the stack-dispatched UI steps.
+ *
+ * The UI steps halt with `@agent-directive: ui-apply-<stack>` (and the
+ * `ui-design-review-` / `ui-polish-` equivalents). Those names are **directive
+ * verbs, not skill paths** — the same shape as `run-tests`, `create-plan`, and
+ * `apply-plan`, which likewise resolve to no skill file. Only 2 of the engine's
+ * 11 literal verbs name a real skill, so a verb is something the agent
+ * interprets, and the mapping from verb to the skills that implement it is a
+ * separate fact that has to be written down somewhere.
+ *
+ * Before this module that mapping lived only in a prose table in
+ * `docs/contracts/ui-track-flow.md`. Nothing verified it, and two of its four
+ * rows were wrong: `vue` pointed at the directive verb itself (naming no skill
+ * at all) and `plain` — which is also the fallback for every unrecognised
+ * project — pointed at `blade-ui`, a skill whose frontmatter is
+ * `packs: [laravel]` and which a non-Laravel consumer therefore does not have
+ * installed.
+ *
+ * Keeping the map here makes it checkable: `lint_ui_stack_bundles` asserts every
+ * member resolves to a real skill, and that no lane reachable without the
+ * `laravel` pack names a `laravel`-only skill. A CI check in this repo cannot
+ * see a consumer's installed pack combination, so the second assertion is the
+ * part that actually prevents the `plain → blade-ui` class of defect.
+ */
+
+/** Skills that implement a lane, in the order the agent should load them. */
+export interface StackBundle {
+    /** Skills that build / fix UI for this lane (`apply`, `polish`). */
+    readonly build: ReadonlyArray<string>;
+    /** Skills that review UI for this lane (`review`). */
+    readonly review: ReadonlyArray<string>;
+    /**
+     * True when every skill above ships outside the framework packs, i.e. the
+     * lane is safe as a fallback for a consumer whose packs we cannot predict.
+     * Only lanes marked `pack_agnostic` may be used as `DEFAULT_*`.
+     */
+    readonly pack_agnostic: boolean;
+}
+
+/**
+ * The pack-agnostic pair. Both live in `engineering-base`, so they are present
+ * in every install; both self-describe as stack-neutral
+ * (`ui-component-architect`: "the same lens applies to Blade, Livewire, React,
+ * or Vue trees"; `tailwind-engineer`: "the **how** for any Tailwind-stack
+ * screen"). This is the honest floor for a lane with no framework-specific
+ * executor — not a claim that the lane is fully served.
+ */
+const GENERIC_BUILD: ReadonlyArray<string> = ['ui-component-architect', 'tailwind-engineer'];
+
+/** `design-review` is stack-neutral and ships in `engineering-base`. */
+const GENERIC_REVIEW: ReadonlyArray<string> = ['design-review'];
+
+/**
+ * Lane → bundle. Keys mirror `KNOWN_STACKS`; the dispatch tables in
+ * `apply` / `review` / `polish` keep their own verb strings (a tested public
+ * contract) and consume this map only to name the skills in the halt body.
+ */
+export const STACK_BUNDLES: Readonly<Record<string, StackBundle>> = {
+    'blade-livewire-flux': {
+        build: ['flux', 'livewire', 'blade-ui'],
+        review: GENERIC_REVIEW,
+        pack_agnostic: false,
+    },
+    // Livewire without Flux — the common Laravel frontend. Previously fell
+    // into `plain` because detection required Livewire AND Flux.
+    'blade-livewire': {
+        build: ['livewire', 'blade-ui'],
+        review: GENERIC_REVIEW,
+        pack_agnostic: false,
+    },
+    // Filament is Livewire + Blade + Tailwind under the hood; the same
+    // executors apply. A Filament-specific skill is gated on evidence that
+    // these produce unusable output for it, not assumed.
+    filament: {
+        build: ['livewire', 'blade-ui'],
+        review: GENERIC_REVIEW,
+        pack_agnostic: false,
+    },
+    'react-shadcn': {
+        build: ['react-shadcn-ui'],
+        review: GENERIC_REVIEW,
+        pack_agnostic: false,
+    },
+    // React without Radix/shadcn. `react-shadcn-ui` still carries the React
+    // component idiom; the shadcn-specific parts simply do not apply.
+    react: {
+        build: ['react-shadcn-ui'],
+        review: GENERIC_REVIEW,
+        pack_agnostic: false,
+    },
+    // No Vue executor exists. The previous prose row pointed at the directive
+    // verb itself, which named nothing; the generic pair is a smaller lie and a
+    // stated one — the halt body says the lane has no Vue-specific skill.
+    vue: {
+        build: GENERIC_BUILD,
+        review: GENERIC_REVIEW,
+        pack_agnostic: true,
+    },
+    plain: {
+        build: GENERIC_BUILD,
+        review: GENERIC_REVIEW,
+        pack_agnostic: true,
+    },
+};
+
+/**
+ * Lanes served by the stack-neutral pair rather than a framework executor.
+ *
+ * `plain` and `vue` share the bundle but not the meaning, and the halt body has
+ * to say which it is. For `plain` the pair IS the right answer — there is no
+ * framework to be idiomatic about. For `vue` it is a gap: a Vue project has a
+ * definite idiom and the package has no executor for it, so the result must not
+ * read as Vue support.
+ */
+export const GENERIC_LANES: ReadonlySet<string> = new Set(['vue', 'plain']);
+
+/** Lanes where the stack-neutral pair is the correct answer, not a shortfall. */
+const NATIVELY_GENERIC_LANES: ReadonlySet<string> = new Set(['plain']);
+
+/**
+ * The label detection returns for a framework it recognises but does not
+ * model. Mirrors `stack/detect.ts::UNSUPPORTED_STACK`; duplicated as a literal
+ * because this module is import-free by design (the detector is a leaf module
+ * the directives must not depend on).
+ */
+export const UNSUPPORTED_LANE = 'unknown';
+
+/** Return the bundle for `stack`, or the `plain` bundle when unmapped. */
+export function bundle_for(stack: string): StackBundle {
+    return STACK_BUNDLES[stack] ?? (STACK_BUNDLES['plain'] as StackBundle);
+}
+
+/**
+ * Questions for the refusal halt on an unmodelled framework.
+ *
+ * Not a directive — there is nothing honest to dispatch to. The agent names
+ * the actual markers from the manifest (it has filesystem access; the engine
+ * deliberately does not carry them on `StackResult`), and the user chooses
+ * between the stack-neutral floor and stopping.
+ */
+export function unsupported_stack_questions(step: string): string[] {
+    return [
+        '> Detection found a frontend framework this package does not model, ' +
+            `so there is no \`${step}\` lane for it.`,
+        '> Name the markers you see in `composer.json` / `package.json` so the ' +
+            'choice below is made on the real stack, not on a guess.',
+        '> 1. Continue on the stack-neutral floor — `ui-component-architect` + ' +
+            '`tailwind-engineer`. Output will not be idiomatic for this ' +
+            'framework; say so in the result.',
+        '> 2. Abort — drop this UI request and add a lane first ' +
+            '(`docs/contracts/ui-stack-extension.md`).',
+    ];
+}
+
+/**
+ * Render the "load these skills" line for a dispatch halt.
+ *
+ * The engine cannot load a skill itself; naming the bundle is what stops the
+ * agent from resolving an unresolvable verb by guessing. A lane with no
+ * framework-specific executor says that outright rather than presenting the
+ * generic pair as if it were stack support.
+ */
+export function bundle_line(stack: string, role: 'build' | 'review'): string {
+    const bundle = bundle_for(stack);
+    const skills = role === 'review' ? bundle.review : bundle.build;
+    const rendered = skills.map((name) => `\`${name}\``).join(' + ');
+    if (NATIVELY_GENERIC_LANES.has(stack)) {
+        return `> Skills: ${rendered} — stack-neutral, which is what \`${stack}\` means.`;
+    }
+    if (GENERIC_LANES.has(stack)) {
+        return (
+            `> Skills: ${rendered} — there is no \`${stack}\`-specific executor, ` +
+            'so this is the stack-neutral floor, not idiomatic ' +
+            `\`${stack}\`. Say so in the result.`
+        );
+    }
+    return `> Skills: ${rendered}.`;
+}

package/src/agent-src/templates/scripts/work_engine/stack/detect.ts

@@ -17,17 +17,35 @@
  *
  * 1. `composer.json` lists `livewire/livewire` AND `livewire/flux` →
  *    `blade-livewire-flux`
- * 2. `package.json` lists `react` AND any of `@radix-ui/*`,
+ * 2. `composer.json` lists `filament/filament` → `filament` (before bare
+ *    Livewire: Filament pulls Livewire in transitively)
+ * 3. `composer.json` lists `livewire/livewire` → `blade-livewire`
+ * 4. `package.json` lists `react` AND any of `@radix-ui/*`,
  *    `shadcn-ui` or has a `components.json` (the shadcn marker file)
  *    → `react-shadcn`
- * 3. `package.json` lists `vue` (any major) → `vue`
- * 4. Otherwise → `plain`
+ * 5. `package.json` lists `react` → `react`
+ * 6. `package.json` lists `vue` (any major) → `vue`
+ * 7. Either manifest names a recognised-but-unmodelled framework
+ *    (Svelte, Angular, Nuxt, Astro, Solid, Qwik, Inertia) → `unknown`
+ * 8. Otherwise → `plain`
+ *
+ * Rules 3, 5 and 7 exist because the earlier table sent three common
+ * shapes into `plain`: Laravel+Livewire without Flux failed rule 1's `&&`,
+ * React without Radix failed rule 4, and every unmodelled framework was
+ * indistinguishable from a genuinely plain project. `plain` now means "no
+ * frontend markers"; `unknown` means "a framework we do not model", and
+ * dispatch refuses on it rather than handing over generic tooling silently.
  *
  * Detection is filesystem-cheap: at most three small JSON reads per
  * project root. Errors (missing file, malformed JSON, missing `require`
  * section) downgrade to `plain` rather than raising — a wrong stack
  * label is recoverable (audit catches it, user can override), but a
  * crash mid-dispatch is not.
+ *
+ * Root manifests only, by design: a monorepo caller passes the workspace
+ * root that carries the manifest it cares about. Note the consequence —
+ * a caller that always passes the repository root gets `plain` for a
+ * monorepo, so the caller owns scope selection, not the detector.
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -43,18 +61,59 @@ import * as path from 'node:path';
  */
 export const KNOWN_STACKS: ReadonlySet<string> = new Set([
     'blade-livewire-flux',
+    'blade-livewire',
+    'filament',
     'react-shadcn',
+    'react',
     'vue',
     'plain',
+    'unknown',
 ]);
 
-/** Fallback when no manifest signal matches. */
+/**
+ * Label for a project with no frontend markers at all.
+ *
+ * `plain` used to carry two meanings — "genuinely a plain HTML/Tailwind
+ * project" and "detection failed, here is generic tooling anyway" — which made
+ * a loud failure impossible without punishing real plain projects. The second
+ * meaning is now {@link UNSUPPORTED_STACK}.
+ */
 export const DEFAULT_STACK = 'plain';
 
+/**
+ * Label for a project whose frontend IS recognisable but is not modelled.
+ *
+ * Dispatch refuses on this label instead of degrading to generic tooling: a
+ * Filament or Svelte project silently routed to a Tailwind-only bundle is
+ * user-hostile precisely because the output looks like it worked.
+ */
+export const UNSUPPORTED_STACK = 'unknown';
+
 const _SHADCN_RADIX_PREFIX = '@radix-ui/';
 const _SHADCN_PACKAGE_NAMES: ReadonlySet<string> = new Set(['shadcn-ui', 'shadcn']);
 const _FLUX_PACKAGE = 'livewire/flux';
 const _LIVEWIRE_PACKAGE = 'livewire/livewire';
+const _FILAMENT_PACKAGE = 'filament/filament';
+
+/**
+ * Frontend markers this package recognises but does not model.
+ *
+ * One of these present means detection **succeeded** at recognising a
+ * framework and the package simply has no lane for it — the `unknown` case,
+ * not the `plain` case. Keep the list short and factual; a marker leaves it
+ * only when a real lane exists.
+ */
+const _UNMODELLED_MARKERS: ReadonlyArray<string> = [
+    'svelte',
+    '@angular/core',
+    'nuxt',
+    'astro',
+    'solid-js',
+    '@builder.io/qwik',
+    '@inertiajs/vue3',
+    '@inertiajs/react',
+    'inertiajs/inertia-laravel',
+];
 
 /**
  * A heterogeneous JSON object, mirroring a Python `dict[str, object]`.
@@ -109,14 +168,51 @@ export function detect_stack(project_root: string): StackResult {
         return new StackResult({ frontend: 'blade-livewire-flux', mtime });
     }
 
+    // Filament before bare Livewire: it pulls Livewire in transitively, so a
+    // Filament project would otherwise be labelled by its dependency rather
+    // than by the framework the developer actually works in.
+    if (_has_package(composer, ['require', 'require-dev'], _FILAMENT_PACKAGE)) {
+        return new StackResult({ frontend: 'filament', mtime });
+    }
+
+    // Livewire WITHOUT Flux is the common Laravel frontend, not an unknown
+    // one. It used to fail the `&&` above and land in `plain`.
+    if (_has_package(composer, ['require', 'require-dev'], _LIVEWIRE_PACKAGE)) {
+        return new StackResult({ frontend: 'blade-livewire', mtime });
+    }
+
     if (_is_react_shadcn(pkg, components_json)) {
         return new StackResult({ frontend: 'react-shadcn', mtime });
     }
 
+    // React without Radix/shadcn is a served stack, not an unknown one.
+    if (_has_package(pkg, _PKG_DEP_KEYS, 'react')) {
+        return new StackResult({ frontend: 'react', mtime });
+    }
+
     if (_has_vue(pkg)) {
         return new StackResult({ frontend: 'vue', mtime });
     }
 
+    // A recognised-but-unmodelled framework is NOT `plain`. Refusing here is
+    // the point: `plain` means "no frontend markers", and conflating the two
+    // is what let a Svelte or Inertia project receive Tailwind-only tooling
+    // and no warning.
+    if (_has_unmodelled_marker(composer, pkg)) {
+        return new StackResult({ frontend: UNSUPPORTED_STACK, mtime });
+    }
+
+    // Monorepo: no manifest at the root, but one sits in a workspace directory.
+    // That is a wrong-scope call, not a plain project — the caller owns scope
+    // selection, so say so instead of labelling the whole repo `plain` and
+    // dispatching generic tooling at it.
+    //
+    // A repo with no manifest ANYWHERE stays `plain`: that is greenfield, and
+    // the scaffold path depends on it.
+    if (mtime === 0.0 && _has_nested_manifest(project_root)) {
+        return new StackResult({ frontend: UNSUPPORTED_STACK, mtime });
+    }
+
     return new StackResult({ frontend: DEFAULT_STACK, mtime });
 }
 
@@ -185,6 +281,61 @@ function _all_dependencies(manifest: Manifest, ...keys: string[]): Manifest {
     return merged;
 }
 
+/** Dependency sections a `package.json` can carry. */
+const _PKG_DEP_KEYS: ReadonlyArray<string> = [
+    'dependencies',
+    'devDependencies',
+    'peerDependencies',
+    'optionalDependencies',
+];
+
+/** True when `name` appears in any of `manifest`'s named dependency sections. */
+function _has_package(
+    manifest: Manifest,
+    sections: ReadonlyArray<string>,
+    name: string,
+): boolean {
+    return name in _all_dependencies(manifest, ...sections);
+}
+
+/** Workspace directories a monorepo conventionally puts its packages in. */
+const _WORKSPACE_DIRS: ReadonlyArray<string> = ['packages', 'apps', 'services', 'libs'];
+
+/**
+ * True when no root manifest exists but a workspace directory holds one.
+ *
+ * Deliberately shallow — one `readdir` per conventional workspace directory,
+ * one `stat` per child. It answers "was this called at the wrong scope?", not
+ * "where is the real project", which stays the caller's job.
+ */
+function _has_nested_manifest(project_root: string): boolean {
+    for (const dir of _WORKSPACE_DIRS) {
+        const base = path.join(project_root, dir);
+        let entries: string[];
+        try {
+            entries = fs.readdirSync(base);
+        } catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (
+                _is_file(path.join(base, entry, 'composer.json')) ||
+                _is_file(path.join(base, entry, 'package.json'))
+            ) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+/** True when either manifest names a framework we recognise but do not model. */
+function _has_unmodelled_marker(composer: Manifest, pkg: Manifest): boolean {
+    const composer_deps = _all_dependencies(composer, 'require', 'require-dev');
+    const pkg_deps = _all_dependencies(pkg, ..._PKG_DEP_KEYS);
+    return _UNMODELLED_MARKERS.some((marker) => marker in composer_deps || marker in pkg_deps);
+}
+
 function _is_blade_livewire_flux(composer: Manifest): boolean {
     const deps = _all_dependencies(composer, 'require', 'require-dev');
     return _LIVEWIRE_PACKAGE in deps && _FLUX_PACKAGE in deps;

package/src/agent-src/templates/scripts/work_engine/state.ts

@@ -629,10 +629,12 @@ function _validate_app_spec(app_spec: JsonValue): void {
  * agent-directive that populates it. An empty dict is the in-progress
  * shape after the skill returns but before the brief lands; the gate
  * treats it the same as `null`. Once populated, `design_confirmed`
- * (when present) must be a bool. Other keys (`layout`, `components`,
- * `states`, `microcopy`, `a11y`, `reused_from_audit`) are
- * validated by the design handler against the skill contract — the
- * schema only enforces shape, not content.
+ * (when present) must be a bool, and `states` (when present and not
+ * `null`) must be an object — the design gate's per-state loop is
+ * object-guarded, so a string or list would bypass all five checks.
+ * The remaining keys (`layout`, `components`, `microcopy`, `a11y`,
+ * `reused_from_audit`) are validated by the design handler against the
+ * skill contract — the schema only enforces shape, not content.
  */
 function _validate_ui_design(ui_design: JsonValue): void {
     if (ui_design === null) {
@@ -652,6 +654,21 @@ function _validate_ui_design(ui_design: JsonValue): void {
             'state.ui_design.design_confirmed must be a boolean when present',
         );
     }
+    // `states` is shape-checked here, not left to the handler. The design
+    // gate's per-state loop was guarded on "is this an object", so a string or
+    // list silently skipped all five required-state checks — the gate passed
+    // while covering no state at all. Rejecting the wrong shape at the schema
+    // boundary means the loop can no longer be bypassed by type.
+    if (
+        'states' in ui_design &&
+        ui_design['states'] !== null &&
+        !_isDict(ui_design['states'])
+    ) {
+        throw new SchemaError(
+            'state.ui_design.states must be a JSON object (one key per ' +
+                `required state) or null; got ${pyTypeName(ui_design['states'])}`,
+        );
+    }
 }
 
 /**

package/src/config/agent-settings.template.yml

@@ -145,6 +145,36 @@ rule_loading_tier: __RULE_LOADING_TIER__
 lean_projection:
   mode: eager-all
 
+# --- Telegraph condensation (output-side) ---
+#
+# speak_scope: off | prose_only | aggressive   (QUOTE the value — bare `off` is a
+#                                              YAML 1.1 boolean, not the string)
+#
+# `off` is the shipped default per docs/adrs/telegraph/0001-default-off-until-bench.md
+# (Status: accepted) and docs/contracts/condensation-default-kill-criterion.md.
+# Reason it is off: the only output-side bench (telegraph-v1, n=10, 2026-05-16)
+# measured median vs_terse -9.27% (API counts) / -5.47% (exact cl100k_base
+# re-analysis) — telegraph emits MORE tokens than a plain "be terse" instruction.
+# The kill-criterion table therefore lands on "criterion not met — defer" and the
+# telemetry multiplier stays suspended (0.9155 < 1.0).
+#
+# NOTE: `speak_scope: off` disables the BEHAVIOUR but not the COST — the projector
+# gates this rule on `telegraph.speak`, never on speak_scope, so under
+# `lean_projection.mode: eager-all` the ~982-token body still ships every session.
+# Set `speak: false` for zero-cost dormancy.
+#
+# Stated explicitly here because until 2026-07-29 this default existed only in
+# prose — and two prose sources disagreed (the rule said prose_only, the accepted
+# ADR said off). Do not flip without a passing output-side bench.
+telegraph:
+  # speak: false = DORMANT (the shipped default per docs/adrs/telegraph/0002).
+  # The rule is omitted from dist/router.json entirely, so its ~982-token body
+  # never ships. This — not speak_scope — is the lever that stops the cost:
+  # compile_router gates on `speak` and never reads speak_scope.
+  # Set true only after an output-side bench clears the kill-criterion bar.
+  speak: false
+  speak_scope: "off"
+
 # --- Token-rich skills governance ---
 #
 # Skills marked `token_budget_class: rich` in their frontmatter are exempt
@@ -642,7 +672,7 @@ subagents:
   # delegate frontier-priced or speculative work. `resolveShippedDefault()`
   # remains the telemetry-driven DEMOTION gate: a measured regression demotes
   # back to `ask`.
-  auto: on
+  auto: "on"
 
   # Route delegable sub-tasks to the lowest-capable model tier (cost + speed
   # via model downshift). true (default) = downshift per declared model_tier;
@@ -1114,7 +1144,7 @@ decision_engine:
   #   low    = refuse to advance when band is below low
   #   medium = refuse when below medium
   #   high   = refuse when below high
-  min_confidence: off
+  min_confidence: "off"
 
   # Risk-class ceiling for Phase=Implement.
   #   off    = no ceiling (default)