@event4u/agent-config 8.12.0 → 9.0.0

package/docs/guidelines/design-fidelity-mechanics.md

@@ -0,0 +1,76 @@
+# Design Fidelity — Mechanics
+
+> Surgical-edit discipline, asset & imagery floor, and the failure-mode catalog for the `design-fidelity` rule
+
+_Origin: migrated from `src/rules/design-fidelity.md` per the P4 pattern of `road-to-kernel-and-router.md`. The Iron Law, the `design.fidelity_mode` strictness table, and the fire/not-fire scope stay in the rule; this file carries the illustrative depth._
+
+## Surgical visual edits
+
+A request to change one visual thing — a colour, a label, a single element — is
+a **targeted edit**, not a redesign licence. Apply the same
+`minimal-safe-diff` discipline to design work that backend edits have
+always owed.
+
+- **Change only the semantic target.** Preserve the surrounding layout,
+  spacing, typography, dimensions, content, animation, and interaction states.
+  Do not rewrite the component, reflow the section, or "modernise" neighbours
+  while you are in there. (fixtures: `daf-edit-preservation`, `daf-unwanted-variations`.)
+- **A broader redesign needs an explicit trigger.** Only phrases like *"new
+  direction"*, *"from scratch"*, *"make it feel premium"*, *"rework the flow"*,
+  or *"give me variations / options"* license a from-scratch rework. Absent such
+  a phrase, a "fix / change / update the X" request is surgical — when unsure
+  which, ask (`ask-when-uncertain`). (fixture: `daf-redesign-trigger`.)
+- **Preserve stable anchors.** Where the host exposes DOM/comment metadata, keep
+  comment anchors and screen labels intact so the edit stays locatable. Where
+  the host has no such surface, preserve stable semantic anchors already present
+  in source comments / `data-*` attributes — never strip them, and do not invent
+  new ones.
+
+## Asset & imagery discipline
+
+Visual artifacts carry **real assets or honest placeholders — never fabricated
+brand evidence**. The design-surface instance of the no-invented-facts floor.
+
+- **Copy owned assets through the project's accepted path.** Reference or copy
+  project-owned assets (logos, icons, fonts, images) via the target project's
+  asset directory/pipeline — never hotlink a design-system's internal URL, never
+  bulk-copy a huge source folder. (fixtures: `daf-missing-asset`, `daf-external-asset-url`.)
+- **Real imagery where inspection matters.** On visual pages/decks, use actual
+  product / place / object / state imagery where the image IS the proof (a
+  product screenshot, a real dashboard state). Decorative atmosphere is not proof
+  — never pass a stock-like or invented image off as the real product. An
+  invented product screenshot is fabricated evidence. (fixture: `daf-invented-screenshot`.)
+- **Icons follow the iconography floor** — no emoji-as-icon in serious UI, no
+  hand-rolled icon when a set exists; see the `iconography` skill § Iconography floor.
+- **Ask before adding material — no unrequested filler.** Never generate copy,
+  placeholder sections, or decorative blocks the user did not ask for to "complete"
+  a design. Brief silent on a region → surface the gap (`ask-when-uncertain`)
+  or leave an honest placeholder; never invent filler to fill space.
+
+## Failure modes
+
+- Swapping the prototype's font / typeface because another "reads better".
+- Replacing a specified control (slider, stepper, chip) with a different control.
+- Dropping or adding an element the prototype shows ("+", a send→stop toggle, a warning chip).
+- Restructuring layout or moving sections "because the flow is better".
+- Treating an internal "honesty gate" or "stub" concern as licence to redesign the UI.
+- Re-running a redesign after the user already said "match the prototype".
+
+## How to surface a deviation — do NOT execute it
+
+Name what the spec shows, what you would change, and why — as a numbered option
+per `user-interaction`. The user picks. Honesty about **behaviour** (a control
+not yet wired) never licenses changing the **design**: a faithful visual plus a
+labelled "not wired yet" note beats an invented redesign.
+
+## Fixtures
+
+Behavioral baseline: the `daf-*` fixtures named above (edit preservation,
+unwanted variations, redesign trigger, missing asset, external asset URL,
+invented screenshot).
+
+## See also
+
+- `design-fidelity` (rule) — Iron Law + `design.fidelity_mode` strictness table.
+- `brand-source-of-truth` / `brand-consistency` — same precedence shape, for registered brand tokens.
+- [`design-modes.md`](design-modes.md) — brand vs product register discriminator.

package/docs/maintainers/branch-protection.md

@@ -71,6 +71,24 @@ second-writer race to protect against; flip to `true` when there are
 concurrent mergers. `required_pull_request_reviews: null` per the
 bus-factor reality above.
 
+## Operating conditions under `strict: false`
+
+`strict: false` drops the branches-up-to-date requirement, so three
+conditions become merge-time habits the config cannot enforce:
+
+- **The checked commit must not change after green CI.** No post-CI
+  amend or force-push on the PR branch — the config already blocks
+  force-pushes to `main`; the same discipline applies to the head that
+  CI checked: what went green is what merges.
+- **Critical checks must have run on the final head before merge.** A
+  human glance at the checks tab on the PR's latest commit — with
+  `strict: false` GitHub does not re-run required checks when the base
+  moves, so the green you see is only as fresh as the head it ran on.
+- **Auto-merge must not be enabled in a way that merges with pending or
+  failed required checks.** Enable auto-merge only once the required
+  list is complete and green on the final head — never as a
+  fire-and-forget while checks are still queued.
+
 ## Rollback
 
 ```bash

package/docs/parity/command-frontmatter.md

@@ -0,0 +1,60 @@
+# Command frontmatter — per-host projection parity
+
+> Which command frontmatter fields each host bridge actually consumes, and the
+> deliberate divergences from the official command-authoring field standard.
+> Source of truth for command definitions: `src/domains/<pack>/<name>/command.md`
+> (projected verbatim to `dist/agent-src/commands/` by the condensation
+> pipeline). Schema: [`command.schema.json`](../../src/scripts/schemas/command.schema.json).
+> Roadmap origin: `road-to-ecosystem-harvest-skill-quality-gates` Phase 4 (Source C).
+
+## Projection paths per host
+
+| Host | Projection | Frontmatter reaches host? |
+|---|---|---|
+| Claude Code | `.claude/skills/<slug>/SKILL.md` — symlink to the command source; rendered copy (with native `model:`) when `model.auto_switch: auto` and a `model_tier` maps | Yes — full frontmatter, verbatim |
+| Cursor | `.cursor/commands/<slug>.md` — symlink to the command source | Yes — file verbatim; Cursor treats unknown frontmatter as inert |
+| Windsurf | `.windsurf/workflows/<slug>.md` — symlink to the command source | Yes — same inert-passthrough as Cursor |
+| Cline / Gemini / Copilot / Roo / Codex / Continue | Text reference via `AGENTS.md` only (no native command surface) | No — invocation is conversational |
+
+## Field consumption matrix (official-standard fields)
+
+| Field | Claude Code | Cursor / Windsurf | Notes |
+|---|---|---|---|
+| `name` | ✅ load rule: must equal the skill directory slug | inert | Path-derived hyphen slug; enforced by `check_host_loadability` |
+| `description` | ✅ routing + display | inert | ≤ 200 chars per schema |
+| `argument-hint` | ✅ rendered next to the slash command | inert | Added Phase 4; set on every command whose body documents an invocation argument (140/183 at introduction) |
+| `disable-model-invocation` | ✅ honored natively | inert (vacuously true — no model-invocation surface) | Schema pins `enum: [true]` — commands are user-invoked by design |
+| `model` | ✅ (rendered copies only) | inert | Never authored by hand: the generator rewrites `model_tier:` → native `model:` at projection time (ADR-034/035) |
+
+All other fields (`tier`, `visibility`, `pack`, `cluster`, `intent`,
+`routes_to`, `replaces`, `suggestion`, `workspaces`, `packs`, `trust`,
+`install`, `model_tier`, …) are **suite governance metadata** — consumed by the
+package's own linters, router, discovery manifest, and docs generators, never
+by a host. Hosts that read the file verbatim ignore them; that is the intended
+contract, not drift.
+
+## Deliberate divergences from the official standard
+
+1. **No colon names.** The official examples allow `/cluster:sub` invocation;
+   this suite forbids colons in `name:` (Agent-Skills-spec compliance for
+   strict consumers like Zed). Claude Code's `/cluster:sub` invocation still
+   works — it is path-derived from `commands/<cluster>/<sub>.md`, not from the
+   `name:` field.
+2. **`disable-model-invocation` is locked to `true`.** The standard allows
+   model-invocable commands; this suite's commands are always user-invoked
+   (`command-suggestion-policy` owns proactive surfacing instead — suggest,
+   never invoke).
+3. **`model` is generated, never authored.** Authors declare the
+   vendor-neutral `model_tier:`; the Claude bridge renders a native `model:`
+   only when the consumer opted into `model.auto_switch: auto`.
+4. **`argument-hint` is host-passthrough.** Only Claude Code renders it today;
+   it stays in the neutral source (harmless elsewhere) rather than being
+   projected host-specifically — per the do-NOT-chase-host-fields rule for the
+   neutral tree.
+
+## Verification
+
+- `./scripts-run src/scripts/validate_frontmatter` — every command validates
+  against the schema (including `argument-hint` shape, ≤ 120 chars).
+- `./scripts-run src/scripts/check_host_loadability --root .` — generated
+  `.claude/skills/` entries parse and satisfy the host load rule.

package/docs/proof.md

@@ -27,8 +27,9 @@ evidence pointer, or `task check-claims` fails the build.
 | Claim | Kind | Evidence | Resolves |
 |---|---|---|---|
 | The release process is documented as an inheritable runbook + succession doc, and the project's bus-factor (trailing-90-day distinct human reviewers) is tracked and reported truthfully — currently 1, not implied to be more. | qual | `docs/succession.md#trailing 90 days` | ✅ |
-| 178 commands. | quant | `src/scripts/check_artefact_count_messaging.ts#Artefact-count messaging gate` | ✅ |
+| 183 commands. | quant | `src/scripts/check_artefact_count_messaging.ts#Artefact-count messaging gate` | ✅ |
 | A MEASURED-BUT-NOT-SHIPPED experiment — the thin rule projection reduced eager rule load 78,513 → 13,881 GPT-tokens (whole always-loaded projection 98,529 → 33,897, ~65.6%), but FAILED the quality gate (thin win-rate 36.2% vs required 48%) and does not ship; it un-defers only behind `discipline_profile: essential`. Shipped behavior does NOT include this reduction. Method: `agent-config benchmark` over the pinned token baseline; the baseline is the honest "what the user pays if everything loads eagerly", NOT a synthetic full-corpus strawman (council Q4); quality gate per the Phase-0 paired judge run. | quant | `internal/bench/reports/token-baseline.json#eager_rule_load` | ✅ |
+| The first cross-vendor parity pass (5 orchestration-corpus tasks × 2 vendors × 3 repeats, identical prompts via the council transport, $0.16) measured real per-host finding-count differences — claude-sonnet-4-5 surfaced ~2× the findings of gpt-4o on the multi-file analysis task (median 11 vs 5) while both vendors were identical on the planted hollow-implementation task (2 vs 2) and perfectly silent on the clean-code negative control (0 vs 0, no spurious findings). The per-task `finding_floor` values are calibrated from the cross-host lower envelope and the gate is armed. | quant | `internal/bench/reports/parity-count.json#min over hosts of median` | ✅ |
 | On a weak host (claude-haiku-4-5) the package produces a significant, placebo-controlled discipline lift on scope/downstream traps; on a strong host the same measurement is a published null — the package transplants discipline a weak model lacks, not model intelligence. | quant | `docs/benchmark.md#weak-host-specific` | ✅ |
 | The non-coding domain skills (finance/founder/ops/content) are forged on TS/PHP and labeled unvalidated until they pass a sourced domain-truth fixture; no public prose implies proven domain correctness, and the validated count is CI-ratcheted. | qual | `src/scripts/domain_soundness_status.ts#checkRatchet` | ✅ |
 | The validated non-coding domain-skill count is pinned and CI-ratcheted at a maintainer-set floor (9 of 20 default-surface skills carry a sourced `evals/domain-truth.json` fixture at pin time, 2026-07-11 — 5 deterministic, keys from cited formulas; 4 rubric, criteria matching a named external practice); the floor only rises via a maintainer `--write-floor` after a new sourced fixture lands. | quant | `internal/evals/domain-soundness-floor.json#validated` | ✅ |
@@ -44,10 +45,10 @@ evidence pointer, or `task check-claims` fails the build.
 | On a deterministic multi-session recall corpus, the memory substrate produces a measured, placebo-controlled recall lift — memory-on 27/27 vs no-memory 10/27 and vs equal-byte placebo 9/27 (claude-haiku-4-5, n=9 tasks x 3 seeds, sign test p=0.031 for BOTH pairings). Scoped honestly: this is the context-value upper bound (perfect retrieval on a one-fact-per-task corpus), not retrieval precision under a large store. | quant | `internal/bench/reports/second-brain-delta.json` | ✅ |
 | Removing the perfect-retrieval assumption, the substrate's REAL keyword retrieval recalls the needed decision into the top-5 under keyword-overlapping confusers (precision@5 9/9) and the model disambiguates it from the co-injected confusers — retrieval-on 27/27 vs no-memory 5/27 and vs equal-count placebo 5/27 (claude-haiku-4-5, 9 tasks x 3 seeds, sign test p=0.008 both). Named limit: retrieval RECALLS but does not RANK (mean tie-set 3.3, ties broken by store order, not relevance) — the discrimination gap that motivates the SQLite-FTS5 activation path (ADR-116) at larger scale. | quant | `internal/bench/reports/second-brain-retrieval.json` | ✅ |
 | Every artifact the package ships — source AND the condensed projection that reaches consumers — is machine-scanned in CI for hidden-Unicode, mixed-script-confusable, and instruction-smuggling payloads (the rules-file-backdoor class); a finding blocks the release before `npm publish`, not just the merge. | qual | `.github/workflows/publish-npm.yml#lint_agent_security` | ✅ |
-| 271 skills. | quant | `src/scripts/check_artefact_count_messaging.ts#Artefact-count messaging gate` | ✅ |
+| 274 skills. | quant | `src/scripts/check_artefact_count_messaging.ts#Artefact-count messaging gate` | ✅ |
 | Removes only its own keys from a shared host config (matched by JSON-pointer + SHA-256), never a neighbour tool's entries. | qual | `docs/contracts/install-layout.md#JSON-pointer` | ✅ |
 
-**20 backed claim(s)** — all evidence pointers resolve in CI.
+**21 backed claim(s)** — all evidence pointers resolve in CI.
 
 Artefact counts in public prose (skills, commands, governed rules,
 guidelines, personas) are **generated from source and CI-drift-checked**:
@@ -76,11 +77,11 @@ shipping theater; the full per-cell data is committed at
 `internal/bench/reports/persona-placebo.json`.
 
 **Behavioural-eval coverage — the honest baseline.** Skill *quality* is only
-as good as its measurement. Today **39 of 271** skills carry a behavioural
+as good as its measurement. Today **42 of 274** skills carry a behavioural
 `evals.json`; the highest-traffic / highest-cost tiers (default-surface +
 `rich` + routers) are **fully covered (35 of 35)**, the long tail
-(4 of 236) is not. We publish that gap rather than imply
-"271 evaluated skills": coverage is measured per tier
+(7 of 239) is not. We publish that gap rather than imply
+"274 evaluated skills": coverage is measured per tier
 (`./scripts-run src/scripts/skill_eval_coverage`), **CI-ratcheted so it can
 only rise**, and the priority tiers carry a hard **tier floor**: every
 rich / default-surface / router skill MUST have a behavioural eval or an

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@event4u/agent-config",
-    "version": "8.12.0",
+    "version": "9.0.0",
     "description": "Universal AI Agent OS — audited skills, governance rules, commands, and templates for AI coding tools (Claude Code, Cursor, Windsurf, Copilot).",
     "license": "MIT",
     "private": false,

package/src/agent-src/templates/scripts/telemetry/engagement.ts

@@ -15,6 +15,10 @@
  *       "boundary_kind": "task" | "phase-step" | "tool-call",
  *       "consulted": {"skills": [...], "rules": [...], ...},
  *       "applied":   {"skills": [...], "rules": [...], ...},
+ *       "loaded":    {"skills": [...], "rules": [...], ...}  # optional (U1a):
+ *              what was AVAILABLE/INJECTED at the boundary — the Fired/Loaded
+ *              denominator. Superset contract: consulted ⊆ loaded. Ids only
+ *              (same PII-exclusion-by-construction shape as consulted).
  *       "outcomes":  ["blocked", "verification_failed", ...]  # optional
  *       "tokens_estimate": {"consulted_load": <int>}   # optional
  *     }
@@ -127,6 +131,7 @@ export interface EngagementEventInit {
     boundary_kind: string;
     consulted?: Record<string, string[]>;
     applied?: Record<string, string[]>;
+    loaded?: Record<string, string[]> | null;
     outcomes?: string[] | null;
     tokens_estimate?: Record<string, number> | null;
     schema_version?: number;
@@ -138,6 +143,7 @@ export class EngagementEvent {
     boundary_kind: string;
     consulted: Record<string, string[]>;
     applied: Record<string, string[]>;
+    loaded: Record<string, string[]> | null;
     outcomes: string[] | null;
     tokens_estimate: Record<string, number> | null;
     schema_version: number;
@@ -148,6 +154,7 @@ export class EngagementEvent {
         this.boundary_kind = init.boundary_kind;
         this.consulted = init.consulted ?? {};
         this.applied = init.applied ?? {};
+        this.loaded = init.loaded ?? null;
         this.outcomes = init.outcomes ?? null;
         this.tokens_estimate = init.tokens_estimate ?? null;
         this.schema_version = init.schema_version ?? SCHEMA_VERSION;
@@ -171,6 +178,20 @@ export class EngagementEvent {
         }
         _validate_artefact_dict('consulted', this.consulted);
         _validate_artefact_dict('applied', this.applied);
+        if (this.loaded !== null) {
+            _validate_artefact_dict('loaded', this.loaded);
+            for (const [kind, ids] of Object.entries(this.consulted)) {
+                const avail = new Set(this.loaded[kind] ?? []);
+                for (const art_id of ids) {
+                    if (!avail.has(art_id)) {
+                        throw new EngagementSchemaError(
+                            `consulted.${kind} id '${art_id}' missing from loaded.${kind}; `
+                            + 'superset contract: consulted \u2286 loaded',
+                        );
+                    }
+                }
+            }
+        }
         if (this.outcomes !== null) {
             _validate_outcomes(this.outcomes);
         }
@@ -206,6 +227,12 @@ export class EngagementEvent {
             consulted: _normalise_artefact_dict(this.consulted),
             applied: _normalise_artefact_dict(this.applied),
         };
+        if (this.loaded !== null) {
+            const norm = _normalise_artefact_dict(this.loaded);
+            if (Object.keys(norm).length > 0) {
+                out['loaded'] = norm;
+            }
+        }
         if (this.outcomes && this.outcomes.length > 0) {
             out['outcomes'] = [...this.outcomes];
         }
@@ -310,6 +337,9 @@ export function parse_event(line: string): EngagementEvent {
         boundary_kind: (r['boundary_kind'] as string) ?? '',
         consulted: _orEmptyDict(r['consulted']),
         applied: _orEmptyDict(r['applied']),
+        loaded: r['loaded'] === undefined || r['loaded'] === null
+            ? null
+            : _orEmptyDict(r['loaded']),
         outcomes: (r['outcomes'] as string[] | null | undefined) ?? null,
         tokens_estimate: (r['tokens_estimate'] as Record<string, number> | null | undefined) ?? null,
         schema_version: r['schema_version'] === undefined

package/src/agent-src/templates/scripts/telemetry/report_renderer.ts

@@ -121,15 +121,19 @@ export function render_markdown(aggregate: AggregateResult, opts: RenderOptions
             lines.push('');
             continue;
         }
-        lines.push('| kind | id | consulted | applied | applied/consulted | last seen |');
-        lines.push('|---|---|---:|---:|---:|---|');
+        const withLoaded = aggregate.loaded_events > 0;
+        lines.push(withLoaded
+            ? '| kind | id | loaded | consulted | applied | fired/loaded | applied/consulted | last seen |'
+            : '| kind | id | consulted | applied | applied/consulted | last seen |');
+        lines.push(withLoaded ? '|---|---|---:|---:|---:|---:|---:|---|' : '|---|---|---:|---:|---:|---|');
         for (const entry of rows) {
             const s = entry.stat;
             check_id_redaction(`buckets.${s.kind}.id`, s.artefact_id);
-            lines.push(
-                `| ${s.kind} | \`${s.artefact_id}\` | ${s.consulted} | ${s.applied} `
-                + `| ${_pyFixed(s.applied_ratio, 2)} | \`${s.last_seen_ts}\` |`,
-            );
+            lines.push(withLoaded
+                ? `| ${s.kind} | \`${s.artefact_id}\` | ${s.loaded} | ${s.consulted} | ${s.applied} `
+                    + `| ${_pyFixed(s.fired_ratio, 2)} | ${_pyFixed(s.applied_ratio, 2)} | \`${s.last_seen_ts}\` |`
+                : `| ${s.kind} | \`${s.artefact_id}\` | ${s.consulted} | ${s.applied} `
+                    + `| ${_pyFixed(s.applied_ratio, 2)} | \`${s.last_seen_ts}\` |`);
         }
         lines.push('');
     }
@@ -147,7 +151,9 @@ export function render_json(aggregate: AggregateResult, opts: RenderOptions = {}
         [BUCKET_BOTTOM]: [],
     };
     for (const entry of bucketed) {
-        (grouped[entry.bucket] as Array<Record<string, unknown>>).push(_stat_to_dict(entry.stat));
+        (grouped[entry.bucket] as Array<Record<string, unknown>>).push(
+            _stat_to_dict(entry.stat, aggregate.loaded_events > 0),
+        );
     }
     if (top !== null) {
         for (const bucket of Object.keys(grouped)) {
@@ -179,9 +185,9 @@ export function render_json(aggregate: AggregateResult, opts: RenderOptions = {}
     return `${_py_json_dumps_indent2_sorted(payload)}\n`;
 }
 
-function _stat_to_dict(stat: ArtefactStat): Record<string, unknown> {
+function _stat_to_dict(stat: ArtefactStat, withLoaded = false): Record<string, unknown> {
     check_id_redaction(`buckets.${stat.kind}.id`, stat.artefact_id);
-    return {
+    const out: Record<string, unknown> = {
         kind: stat.kind,
         id: stat.artefact_id,
         consulted: stat.consulted,
@@ -189,6 +195,13 @@ function _stat_to_dict(stat: ArtefactStat): Record<string, unknown> {
         applied_ratio: new PyFloat(_pyRound(stat.applied_ratio, 4)),
         last_seen_ts: stat.last_seen_ts,
     };
+    // U1a: emitted only when the log carries the loaded denominator, so
+    // pre-U1a logs render byte-identically to the frozen parity oracle.
+    if (withLoaded) {
+        out['loaded'] = stat.loaded;
+        out['fired_ratio'] = new PyFloat(_pyRound(stat.fired_ratio, 4));
+    }
+    return out;
 }
 
 // ── Python-parity helpers ───────────────────────────────────────────────

package/src/agent-src/templates/scripts/telemetry_record.ts

@@ -63,6 +63,7 @@ interface RecordArgs {
     boundary: string;
     consulted: string[] | null;
     applied: string[] | null;
+    loaded: string[] | null;
     outcome: string[] | null;
     ts: string;
     payload_file: string | null;
@@ -78,6 +79,7 @@ function _build_event_from_args(args: RecordArgs): EngagementEvent {
         boundary_kind: args.boundary,
         consulted: _parse_kv_list(args.consulted ?? []),
         applied: _parse_kv_list(args.applied ?? []),
+        loaded: args.loaded && args.loaded.length > 0 ? _parse_kv_list(args.loaded) : null,
         outcomes: args.outcome && args.outcome.length > 0 ? [...args.outcome] : null,
     });
 }
@@ -101,6 +103,7 @@ function _build_event_from_payload(raw: string): EngagementEvent {
         boundary_kind: (d['boundary_kind'] as string) ?? '',
         consulted: _orEmpty(d['consulted']),
         applied: _orEmpty(d['applied']),
+        loaded: d['loaded'] === undefined || d['loaded'] === null ? null : _orEmpty(d['loaded']),
         outcomes: (d['outcomes'] as string[] | null | undefined) ?? null,
         tokens_estimate: (d['tokens_estimate'] as Record<string, number> | null | undefined) ?? null,
     });
@@ -121,6 +124,7 @@ function _parseArgs(argv: string[]): RecordArgs {
         boundary: 'task',
         consulted: null,
         applied: null,
+        loaded: null,
         outcome: null,
         ts: '',
         payload_file: null,
@@ -155,6 +159,7 @@ function _parseArgs(argv: string[]): RecordArgs {
             }
             a.boundary = v;
         } else if (tok === '--consulted') (a.consulted ??= []).push(next());
+        else if (tok === '--loaded') (a.loaded ??= []).push(next());
         else if (tok === '--applied') (a.applied ??= []).push(next());
         else if (tok === '--outcome') {
             const v = next();

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

@@ -62,10 +62,15 @@ projection:
   # rules ALWAYS project (unconditional by definition); untagged rules fail
   # safe and ship. Example consumer scope:
   #   rule_workspaces: [engineering]
-  # Default flip to a scoped value is a human release gate — see
-  # agents/settings/contexts/consumer-scoping-audit-2026-07-07.md.
+  # DEFAULT FLIPPED 2026-07-13 (the Phase-1 human gate, maintainer-approved,
+  # evidence-gated): the default below lists EVERY consumer workspace, so
+  # exactly the exclusively-maintainer specification rules drop from consumer
+  # installs (the audited 16-rule lever — see
+  # agents/settings/contexts/consumer-scoping-audit-2026-07-07.md) while all
+  # domain safety floors and domain rules keep shipping. Narrowing further
+  # (e.g. [engineering] only) stays a per-install user choice.
   # An EMPTY list is inactive (= legacy-all); only a non-empty list scopes.
-  rule_workspaces: []
+  rule_workspaces: [engineering, product, finance, founder, gtm, ops, small-business, construction, legal-review-prep]
   #
   # Optional second axis, same semantics per pack ids (packs.yml). When set,
   # a non-kernel rule also needs a `packs:` intersection to project — e.g.
@@ -622,13 +627,72 @@ worktrees:
 
 # --- AI Council (external second-opinion network) ---
 #
-# Configuration moved to `agents/.ai-council.yml` as of the Step-2
-# consolidation roadmap. Consumer projects opt in by copying the
-# reference file from the package (`agents/.ai-council.yml`) into their
-# own `agents/` tree and flipping `enabled: true` per provider.
+# The council config is NOT here and is NOT project-local. It lives ONLY
+# user-global at `~/.event4u/agent-config/settings/.ai-council.yml` — one
+# file, configured once, serving every project / worktree / CWD (ADR-104,
+# superseding ADR-093). The project tree is NEVER searched; a
+# `.ai-council.yml` under any `agents/` tree is ignored. To opt in, copy
+# the shape from `agents/templates/.ai-council.yml.example` to that
+# user-global path and flip `enabled: true` per provider — do NOT drop it
+# into a project's `agents/` tree.
 #
 # See `docs/contracts/ai-council-config.md` for the schema.
 
+# --- AI Team (cross-model strong-pair review — /team family) ---
+#
+# Governs the default-off `/team` capability family: one strong external
+# model (via the codex CLI, subscription-authed) reviews inside the repo —
+# the depth complement to the council's breadth. Schema + validation
+# contract: `docs/contracts/ai-team-config.md`. The loader
+# (`src/scripts/ai_team/config.ts`) rejects unknown keys fail-closed.
+ai_team:
+  # Master switch. false (default) = /team commands are never suggested
+  # and every invocation refuses with an enable pointer; true = the
+  # family is live (individual gates below still apply).
+  enabled: false
+
+  # Model handed to the codex CLI. 'auto' (default) = pass NO --model
+  # flag, the codex CLI's own default applies — this tracks the
+  # subscription's current strongest model instead of pinning a stale
+  # ID. Any other value passes through verbatim as `--model <value>`.
+  model: auto
+
+  # Second opt-in for the ONLY wrapper that delegates write access
+  # (/team:delegate → the plugin's native-Codex worker). false (default)
+  # = delegate refuses with an enable pointer even when ai_team.enabled
+  # is true. Both keys must be true before delegation is reachable.
+  allow_delegate: false
+
+  # Per-day cap on team calls. Team calls count into the EXISTING
+  # cli_call_budget openai bucket (~/.event4u/agent-config/cli-calls.json,
+  # daily UTC reset) — one subscription, one counter, never a parallel
+  # count. This key is the team-side ceiling read against that shared
+  # bucket. 0 = block all team calls; raise if you review heavily.
+  max_calls_per_day: 50
+
+  # Suppress the one-line wizard/init recommendation to set up the codex
+  # plugin on Claude-Code hosts. Cosmetic only — never changes behavior.
+  suppress_setup_hint: false
+
+  # Managed governance of the codex plugin's Stop-hook Review Gate
+  # (road-to-team-mode Phase 4). The gate itself stays upstream's; these
+  # keys only govern it. Upstream's own warning: "The review gate can
+  # create a long-running Claude/Codex loop and may drain usage limits
+  # quickly."
+  review_gate:
+    # false (default) = byte-identical pre-Phase-4 behavior: no counting,
+    # no circuit breaker, our Stop path never touches the gate. true =
+    # count consecutive BLOCK verdicts per session and trip the circuit
+    # breaker at the bound below.
+    managed: false
+
+    # Circuit-breaker bound: after this many CONSECUTIVE BLOCK verdicts
+    # in one session, a visible notice is injected exactly once and the
+    # managed layer stops re-blocking — the user decides, never an
+    # infinite Claude↔Codex loop. An ALLOW verdict resets the counter.
+    # Positive integer.
+    max_consecutive_blocks: 3
+
 # --- Onboarding ---
 #
 # Tracks whether the initial setup flow (/onboard) has been completed

package/src/config/prelaunch-areas.yml

@@ -0,0 +1,36 @@
+# Pre-launch diagnostic — fixed coverage-area vocabulary
+# (road-to-ecosystem-harvest-prelaunch-diagnostics Phase 1, Source L).
+#
+# The AREA code is the middle segment of the immutable finding-ID grammar
+# `AC-<AREA>-NNN` (docs/contracts/prelaunch-diagnostics.md). Codes are
+# append-only: renaming or re-using a code would re-assign IDs and break
+# every committed baseline. Add new areas at the end; never delete.
+#
+# `launch_gate: true` areas participate in the regression gate's
+# Pass→Finding CI trigger and block a "ready" verdict while Unknown.
+schema_version: prelaunch-areas-v1
+areas:
+  auth:
+    code: AUTH
+    launch_gate: true
+    description: Authentication, authorization, tenancy boundaries on the launch surface.
+  migrations:
+    code: MIG
+    launch_gate: true
+    description: Schema/data migrations shipped with the launch — reversibility, expand-contract, backfill safety.
+  secrets:
+    code: SEC
+    launch_gate: true
+    description: Secrets, tokens, key handling touched by the launch — storage, rotation, exposure paths.
+  observability:
+    code: OBS
+    launch_gate: false
+    description: Telemetry proving rollout health — the metric, alert, and pager path for the new surface.
+  rollback:
+    code: RBK
+    launch_gate: true
+    description: Rollback contract — trip wires, decision windows, abort paths, named irreversible steps.
+  agent-governance:
+    code: AGOV
+    launch_gate: false
+    description: AI/agent surfaces shipped with the launch — tool grants, egress paths, injection exposure.