@event4u/agent-config 16.5.0 → 17.1.0

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

@@ -0,0 +1,77 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/install/paths.ts
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+var INSTALL_ROOT_SUBPATH = ".event4u/agent-config";
+var INSTALL_LOG_FILENAME = "install-log.jsonl";
+function resolveHome(home) {
+  if (home && home.length > 0) {
+    return home;
+  }
+  const fromOs = homedir();
+  if (!fromOs) {
+    throw new Error(
+      "Cannot resolve home directory \u2014 both $HOME (POSIX) and $USERPROFILE (Windows) are unset."
+    );
+  }
+  return fromOs;
+}
+function getInstallRoot(home) {
+  return join(resolveHome(home), INSTALL_ROOT_SUBPATH);
+}
+function getLogPath(home) {
+  const configHome = home ? void 0 : process.env["EVENT4U_CONFIG_HOME"];
+  if (configHome) return join(configHome, INSTALL_LOG_FILENAME);
+  return join(getInstallRoot(home), INSTALL_LOG_FILENAME);
+}
+
+// src/install/detect.ts
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join as join2, resolve } from "node:path";
+var SCOPE_DETECT_MANIFESTS = [
+  "package.json",
+  "composer.json",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod",
+  "Gemfile"
+];
+var SCOPE_DETECT_AI_DIRS = [
+  ".claude",
+  ".cursor",
+  ".windsurf",
+  ".augment",
+  ".clinerules",
+  ".copilot",
+  ".gemini",
+  ".codex",
+  ".aider",
+  ".continue",
+  ".roo",
+  ".kilocode"
+];
+function detectToolPresence(root) {
+  return {
+    augment: isDir(join2(root, ".augment")),
+    claude: isDir(join2(root, ".claude")),
+    cursor: isDir(join2(root, ".cursor")),
+    cline: isDir(join2(root, ".clinerules")),
+    windsurf: isDir(join2(root, ".windsurf")) || existsSync(join2(root, ".windsurfrules")),
+    agentsMd: existsSync(join2(root, "AGENTS.md"))
+  };
+}
+function isDir(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export {
+  getLogPath,
+  SCOPE_DETECT_MANIFESTS,
+  SCOPE_DETECT_AI_DIRS,
+  detectToolPresence
+};

package/dist/cli-delegate/{chunk-KXXWJTDO.js → chunk-WMNYVIYX.js}

@@ -2,7 +2,7 @@ import { createRequire as __acCreateRequire } from 'node:module'; const require
 import {
   blocker_class,
   collect
-} from "./chunk-PHD7OOLE.js";
+} from "./chunk-MQ2UDEGV.js";
 import {
   GATE_BUDGET_LEDGER_REL,
   appendGateBudgetReceipt,

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

@@ -0,0 +1,181 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  git_common_dir
+} from "./chunk-IAYTIIQW.js";
+import {
+  write_atomic
+} from "./chunk-MWRD5YOH.js";
+import {
+  event4u_root
+} from "./chunk-T6BP34WI.js";
+
+// src/scripts/_lib/session_register.ts
+import fs from "node:fs";
+import path from "node:path";
+var REGISTER_DIRNAME = "agent-sessions";
+var TTL_MEASURED_SECONDS = Object.freeze({
+  claude: 14400
+  // 4 h — raw p99 13 705 s / raw user→user max 14 199 s, rounded up
+});
+var TTL_DEFAULT_SECONDS = 43200;
+function ttl_seconds_for(platform) {
+  const key = String(platform ?? "").trim().toLowerCase();
+  return TTL_MEASURED_SECONDS[key] ?? TTL_DEFAULT_SECONDS;
+}
+function ttl_is_measured(platform) {
+  const key = String(platform ?? "").trim().toLowerCase();
+  return Object.prototype.hasOwnProperty.call(TTL_MEASURED_SECONDS, key);
+}
+var DEREGISTER_ON_STOP_PLATFORMS = /* @__PURE__ */ new Set(["cline"]);
+function stop_means_session_end(platform) {
+  return DEREGISTER_ON_STOP_PLATFORMS.has(String(platform ?? "").trim().toLowerCase());
+}
+var HEARTBEAT_REACHABLE_PLATFORMS = /* @__PURE__ */ new Set([
+  "claude",
+  "augment",
+  // post-reply `stop` only — sufficient for a liveness stamp
+  "cline",
+  // pre-reply `user_prompt_submit` only
+  "windsurf",
+  "gemini"
+]);
+function safe_stem(session_id) {
+  const collapsed = String(session_id ?? "").replace(/\.\./g, "_").replace(/[/\\]/g, "_").replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 128);
+  return /[A-Za-z0-9]/.test(collapsed) ? collapsed : "unknown-session";
+}
+function register_dir(workspace_root) {
+  const common = git_common_dir(workspace_root);
+  return common === null ? null : path.join(common, REGISTER_DIRNAME);
+}
+function global_register_dir(env) {
+  return path.join(event4u_root(env), "runtime", "sessions");
+}
+function iso_now(now = /* @__PURE__ */ new Date()) {
+  return now.toISOString().replace(/\.\d{3}Z$/, "+00:00");
+}
+function epoch_ms(stamp) {
+  if (typeof stamp !== "string" || stamp.length === 0) return null;
+  const ms = Date.parse(stamp);
+  return Number.isFinite(ms) ? ms : null;
+}
+function is_expired(rec, now = /* @__PURE__ */ new Date()) {
+  const seen = epoch_ms(rec.last_seen);
+  if (seen === null) return true;
+  const age_s = (now.getTime() - seen) / 1e3;
+  return age_s > ttl_seconds_for(rec.platform);
+}
+function is_record(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const o = v;
+  return typeof o["session_id"] === "string" && typeof o["last_seen"] === "string";
+}
+function write_record(dir, rec) {
+  try {
+    const target = path.join(dir, `${safe_stem(rec.session_id)}.json`);
+    write_atomic(target, `${JSON.stringify(rec, null, 2)}
+`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function read_own_record(dir, session_id) {
+  try {
+    const target = path.join(dir, `${safe_stem(session_id)}.json`);
+    const parsed = JSON.parse(fs.readFileSync(target, "utf-8"));
+    return is_record(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function delete_record(dir, session_id) {
+  try {
+    fs.unlinkSync(path.join(dir, `${safe_stem(session_id)}.json`));
+    return true;
+  } catch {
+    return false;
+  }
+}
+var PRUNE_GRACE_MS = 24 * 60 * 60 * 1e3;
+function read_live_records(dir, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const prune = options.prune === true;
+  const grace = options.prune_grace_ms ?? PRUNE_GRACE_MS;
+  let names;
+  try {
+    names = fs.readdirSync(dir).filter((n) => n.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const live = [];
+  for (const name of names) {
+    const full = path.join(dir, name);
+    let rec = null;
+    try {
+      const parsed = JSON.parse(fs.readFileSync(full, "utf-8"));
+      rec = is_record(parsed) ? parsed : null;
+    } catch {
+      rec = null;
+    }
+    if (rec === null || is_expired(rec, now)) {
+      if (prune && (rec === null || is_expired(rec, new Date(now.getTime() - grace)))) {
+        try {
+          fs.unlinkSync(full);
+        } catch {
+        }
+      }
+      continue;
+    }
+    live.push(rec);
+  }
+  return live;
+}
+function foreign_live_records(dir, session_id, options = {}) {
+  const own = safe_stem(session_id);
+  return read_live_records(dir, options).filter((r) => safe_stem(r.session_id) !== own);
+}
+function any_live_session(dir, session_id, now = /* @__PURE__ */ new Date()) {
+  const records = session_id === void 0 || session_id === null ? read_live_records(dir, { now }) : foreign_live_records(dir, session_id, { now });
+  return records.length > 0;
+}
+function classify_collisions(others, here) {
+  const out = [];
+  for (const r of others) {
+    if (here.roadmap_slug !== null && r.roadmap_slug !== null && r.roadmap_slug === here.roadmap_slug) {
+      out.push({ kind: "roadmap", record: r });
+    }
+  }
+  for (const r of others) {
+    if (here.branch !== null && r.branch === here.branch) {
+      out.push({ kind: "branch", record: r });
+    }
+  }
+  const mine = new Set(here.owned_paths ?? []);
+  if (mine.size > 0) {
+    for (const r of others) {
+      const shared = (r.owned_paths ?? []).filter((p) => mine.has(p)).sort();
+      if (shared.length > 0) {
+        out.push({ kind: "path", record: r, paths: shared });
+      }
+    }
+  }
+  return out;
+}
+
+export {
+  ttl_seconds_for,
+  ttl_is_measured,
+  stop_means_session_end,
+  HEARTBEAT_REACHABLE_PLATFORMS,
+  safe_stem,
+  register_dir,
+  global_register_dir,
+  iso_now,
+  write_record,
+  read_own_record,
+  delete_record,
+  read_live_records,
+  foreign_live_records,
+  any_live_session,
+  classify_collisions
+};

package/dist/cli-delegate/{chunk-6SRJTYJS.js → chunk-XIAPY44N.js}

@@ -4059,8 +4059,6 @@ var replyMethod = external_exports.enum(["replies_endpoint", "create_review_comm
 var confidenceBand = external_exports.enum(["off", "low", "medium", "high"]);
 var onBlock = external_exports.enum(["stop", "ask", "warn"]);
 var modelAutoSwitch = external_exports.enum(["auto", "suggest", "off"]);
-var leanProjectionMode = external_exports.enum(["eager-all", "thin", "delivery"]);
-var leanProjectionHost = external_exports.enum(["claude-code", "cursor", "cline"]);
 var projectionMode = external_exports.enum(["legacy-all", "scoped"]);
 var projectAudience = external_exports.enum(["self", "internal", "client", "public"]);
 var deliveryMerge = external_exports.enum(["off", "on-green"]);
@@ -4080,11 +4078,8 @@ var settingsSchema = external_exports.object({
     mode: projectionMode.default("legacy-all").describe(
       "Whether the per-tool projector writes EVERY artefact into the host-tool trees (.claude/ .cursor/ .windsurf/) or only the active profile + packs' artefacts (ADR-040, docs/contracts/capability-packs.md). legacy-all = (default, non-breaking) project the full surface exactly as 5.x did. scoped = project only the active profile's packs unioned with the runtime.active_packs overlay, expanded over the requires graph \u2014 opt in with `agent-config use --profile=<id>`. A failed scoped projection restores the full tree."
     ),
-    rule_workspaces: external_exports.array(external_exports.string()).default([]).describe(
-      "Workspace scope for the RULE layer only (road-to-request-scoped-rule-load P1/P1b, opt-in). Absent or empty = legacy-all: every rule projects AND installs. Non-empty = only rules whose workspaces frontmatter intersects this list are projected (condense) and installed (install.sh + global wizard payload). Kernel rules always ship; untagged rules fail safe. The default flip to a scoped value is a HUMAN release gate \u2014 do not set this from automation."
-    ),
     rule_packs: external_exports.union([external_exports.literal("auto"), external_exports.array(external_exports.string())]).default([]).describe(
-      'Optional second scoping axis for the RULE layer, per pack ids (src/config/discovery/packs.yml). When set, a non-kernel rule also needs a packs frontmatter intersection to ship \u2014 e.g. deselecting frontend-design drops ui-audit-gate + design-fidelity. Same opt-in / human-gate semantics as rule_workspaces. The literal "auto" derives the id list from the active-pack set (the same set the skill/command prune uses), so a domain safety floor stops shipping into installs that do not have the pack it guards; an explicit list stays supported and wins over the derivation.'
+      'Scoping axis for the RULE layer beyond the derived workspace set, per pack ids (src/config/discovery/packs.yml). When set, a non-kernel rule also needs a packs frontmatter intersection to ship \u2014 e.g. deselecting frontend-design drops ui-audit-gate + design-fidelity. Opt-in, and an empty list is inactive; the workspace axis beside it is derived rather than configured (ADR-293 step 4.6). The literal "auto" derives the id list from the active-pack set (the same set the skill/command prune uses), so a domain safety floor stops shipping into installs that do not have the pack it guards; an explicit list stays supported and wins over the derivation.'
     )
   }).default({ mode: "legacy-all" }),
   rule_loading_tier: ruleLoadingTier.default("balanced").describe(
@@ -4093,14 +4088,6 @@ var settingsSchema = external_exports.object({
   discipline_profile: disciplineProfile.optional().describe(
     "The ONE runtime knob for the discipline-rule tier (successor of rule_loading_tier; council 2026-07-07). off = kernel only (~1x tokens). essential = kernel + the measured lift-carrying rules (~3.3x, keeps the weak-host discipline lift). full = everything (~11.7x, EXPERIMENTAL \u2014 residual lift over essential not established). auto = resolve per session against the evidence-gated NULL-lift disable-list in src/config/host-capabilities.yml (measured-null host \u2192 off, otherwise \u2192 essential). Optional and opt-in until the P1/P2 evidence gates pass (agents/roadmaps/road-to-discipline-profile-tiering.md); absent = legacy rule_loading_tier applies."
   ),
-  lean_projection: external_exports.object({
-    mode: leanProjectionMode.default("eager-all").describe(
-      "How the per-tool projector emits the rule layer. eager-all = every rule body inlined into every projection (safe; what an ABSENT key still resolves to, per ADR-267 decision point 4). thin = kernel rules full-bodied + non-kernel rules as router-resolved pointers (~45k GPT-tok lighter per session, exact-BPE \u2014 a different unit from the chars/4 figures below, never compare the two directly), with no delivery mechanism. delivery = thin stubs PLUS the rule-inject hook concern, which delivers a body back on a trigger match; this is the value the SHIPPED TEMPLATE carries for Claude Code since ADR-267. SAVING AND CHARGE, MEASURED TOGETHER so neither is published alone (2026-09-12, `check_preamble_payload_budget`): the rule bucket falls 122,769 -> 24,537 chars/4 tok per session on a thinned host (-80.0%), and a trigger match costs p50 6,728 B / p90 14,016 B / max 16,297 B per fire over 318 gate-open fires of the frozen tests/eval/routing-matrix corpus at the concern's 16,384 B cap. Bytes per fire and tokens per session are different denominators and are never summed; re-read both rather than quoting this line. The ceiling for that charge is registered in src/config/hook-token-budget.json (user_prompt_submit slot sum 4,096 -> 16,384)."
-    ),
-    hosts: external_exports.array(leanProjectionHost).default(["claude-code"]).describe(
-      "Which hosts a thinning mode may thin (ADR-267). Absent resolves to [claude-code]. Only the three hosts with a per-rule rule tree are accepted, and this enum is the AUTHORING layer: an id outside it is a hard validation FAILURE here and under validate_agent_settings, never a warning. resolveLeanProjectionHosts is the READ-TIME backstop for a hand-edited .agent-settings.yml that passed neither, and THERE the id is dropped with a warning (R2 finding 6 \u2014 the two layers answer differently and neither said so). Every host outside this list receives exactly what eager-all writes, asserted byte-for-byte by check_host_tree_parity."
-    )
-  }).default({ mode: "eager-all", hosts: ["claude-code"] }),
   cost: external_exports.object({
     budgets: external_exports.object({
       daily: external_exports.number().min(0).default(0).describe(
@@ -4380,8 +4367,8 @@ var settingsSchema = external_exports.object({
     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(
-      "Limit on subagents running in parallel during /do-in-parallel, /do-competitively, and /judge runs \u2014 a value the model reads from settings; no code counts spawns against it. Raise for faster fan-out, lower if you hit rate limits or want lower token spend."
+    max_parallel: external_exports.number().int().min(1).max(64).default(3).describe(
+      "Limit on subagents running in parallel during /do-in-parallel, /do-competitively, and /judge runs. On Claude Code the installer also writes it into CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS, the host cap on concurrent new spawns. That cap does not bound a resumed worker: on Claude Code 2.1.306 a resume was admitted past a cap of 1, so a resume is neither bounded by the host nor counted by any package code yet. Raise for faster fan-out, lower if you hit rate limits or want lower token spend."
     ),
     adversarial_council: external_exports.enum(["off", "ask", "on"]).default("off").describe(
       "Opt-in adversarial-verification-council mode (subagent-orchestration Mode 9, ADR-122). off (default) = never runs; ask = offer it on an explicit high-risk change; on = auto-run on high-risk changes. Advisory only \u2014 a panel of distinct-model skeptics red-teams a real change for defect FINDING coverage and NEVER auto-gates it (Hard Floor). Stays default-off until the adversarial-council-finding-coverage claim is backed."
@@ -4390,6 +4377,12 @@ var settingsSchema = external_exports.object({
   // `worktrees.mode` was DELETED (ADR-229). Worktree creation is
   // instruction-only and hardcoded; there is nothing left to configure. A
   // leftover key is ignored with one deprecation line via REMOVED_KEYS.
+  // `worktrees.cleanup` governs REMOVAL, a separate question (ADR-295).
+  worktrees: external_exports.object({
+    cleanup: external_exports.enum(["off", "notify", "auto"]).default("notify").describe(
+      "What the agent may do about a worktree whose work is provably on the trunk (merged by merge commit, rebase or squash), that is clean, holds no ignored file a rebuild would not restore, and has no live session. notify (default, and what an absent key resolves to) says once a day how many exist and removes nothing; auto removes them right after /pr:merge and once a day on the first session start, without force, keeping local branches; off says nothing. The daily pass reads merged pull requests through your gh login (branch name and head commit only)."
+    )
+  }).default({ cleanup: "notify" }),
   ai_team: external_exports.object({
     model: external_exports.string().default("auto").describe(
       "Model handed to the codex CLI. 'auto' (default) = pass no --model flag so the CLI's own default applies \u2014 tracks the subscription's current strongest model instead of pinning a stale ID. Any other value passes through verbatim as `--model <value>`."
@@ -4448,6 +4441,11 @@ var settingsSchema = external_exports.object({
       "Deterministic run-checkpoint production at session end (road-to-continuity-writer-activation Phase 1.4). on (default) = a session above the recycle threshold and inside a running roadmap contract leaves agents/runtime/state/checkpoints/<run>.json, so a killed run resumes from a derived checkpoint rather than from bookkeeping. off = no checkpoint; continuity writing, the recycle advisory and the context-fill surface are unaffected. Default ON because it is the behavior the tree already had \u2014 the switch exists to make the three session-end handlers independently disableable, not to change what ships."
     )
   }),
+  retro: external_exports.object({
+    enabled: external_exports.boolean().default(true).describe(
+      "Automatic retro after merged work (ADR-292, docs/contracts/retro-v1.md). true (default, owner directive 2026-10-12) = a merged PR and the first session of a new local day enqueue finished work; a deterministic triage picks what is worth one learning, and nothing behavior-changing is applied without a person. The one network read is the daily probe asking GitHub, through your own gh login, whether a pushed PR merged (repository and PR number only, three-second budget). false = no automatic path runs \u2014 no merge enqueue, no forge-merge marker, no daily probe and no network read; an explicit /retro still runs on request. Class C: an agent cannot set it; it cascades from the user-global file."
+    )
+  }).default({}),
   memory: external_exports.object({
     redact_patterns: external_exports.array(external_exports.string()).default([]).describe(
       "Regex patterns (one per line) that scrub matches from chat-history transcripts and memory before they hit disk. Use for secrets, customer names, internal URLs. Patterns are anchored and case-insensitive."
@@ -4469,6 +4467,13 @@ var settingsSchema = external_exports.object({
       )
     }).default({})
   }).default({}),
+  egress: external_exports.object({
+    placeholders: external_exports.object({
+      mode: external_exports.enum(["off", "observe", "protect", "strict"]).default("off").describe(
+        "Dispatcher egress stage (docs/contracts/egress-placeholders-v1.md). off (default) = nothing. observe = detect and count listed values in prompts and tool bodies, types and counts only, and change nothing a hook concern sees. protect = also give every recording and advisory concern a copy with each value replaced by a placeholder token, so local stores keep tokens; guards still see the original. strict = as protect until the host rewrite exists. No mode yet changes what reaches the model; the rule table holds credential rows and the validated identifier rows. Project layers only."
+      )
+    }).default({})
+  }).default({}),
   hooks: external_exports.object({
     concern_budget: external_exports.object({
       tier1_concerns: external_exports.array(external_exports.string()).default([]).describe(
@@ -4549,6 +4554,22 @@ var settingsSchema = external_exports.object({
       "Once per day the agent checks the npm registry for a newer agent-config release and surfaces a one-line banner if one exists. Turn off in air-gapped environments or to silence the banner."
     )
   }),
+  advisories: external_exports.object({
+    mode: external_exports.enum(["off", "notify"]).default("notify").describe(
+      "Whether the first session start of a day prints the advisory findings that need action today. notify (default) reads the local cache only \u2014 a session start never touches the network; off prints nothing, and agent-config audit:deps show still works."
+    ),
+    egress: external_exports.enum(["none", "query"]).default("query").describe(
+      "What leaves the machine when agent-config audit:deps refresh runs. query (default) sends names and versions of public packages to api.osv.dev and reads endoflife.date and the PHP and Node release feeds; a private package name is never sent, and a native npm or composer audit, which sends the lockfile package list to the registry that tool is configured for, runs only for a lockfile with no private package. none sends nothing, and findings read unknown rather than clear."
+    ),
+    kev: external_exports.enum(["off", "on"]).default("on").describe(
+      "Whether a refresh reads the CISA known-exploited catalog. on (default) downloads the whole catalog and matches it locally, so nothing about the project is sent, and a finding in it is raised one tier in a runtime scope; off leaves tiers to the other sources. Runs only where egress is query."
+    )
+  }).default({ mode: "notify", egress: "query", kev: "on" }),
+  update: external_exports.object({
+    mode: external_exports.enum(["off", "notify", "ask", "auto"]).default("notify").describe(
+      "What the agent may do about a newer release. notify tells you and installs nothing (the default, and what an absent key resolves to); ask behaves as notify until the ring-0 exit ships a prompt; auto installs a staged release at a session start when every gate passes and no other session is live; off says nothing at all. Read from the user-global layer only \u2014 a repository cannot set how your global install updates itself."
+    )
+  }).default({ mode: "notify" }),
   legal_review_prep: external_exports.object({
     acknowledged: external_exports.boolean().default(false).describe(
       "I understand the legal-review-prep pack provides templates and general information ONLY \u2014 it is NOT legal advice, creates no attorney-client relationship, and never replaces a licensed lawyer. Individual cases require an attorney. The pack stays inactive until this is checked."

package/dist/cli-delegate/{chunk-H76PHZBI.js → chunk-XLY5G3CM.js}

@@ -15,12 +15,6 @@ var SETTINGS_CARVE_OUT = [
     absentResolvesTo: "legacy-all",
     reason: "The template fallback applies only when NO global settings file exists. Once a file exists, an absent key means legacy-all by documented contract, so an existing install is never silently narrowed on upgrade."
   },
-  {
-    key: "projection.rule_workspaces",
-    reader: "src/install/rule_scope.ts:96 ruleScopeFromSettings",
-    absentResolvesTo: "null \u2014 LEGACY_ALL, i.e. every rule ships including maintainer-only ones",
-    reason: "Same upgrade contract as projection.mode, and the failure is louder: an absent list widens the projection instead of narrowing it."
-  },
   {
     key: "discipline_profile",
     reader: "work_engine/_lib/agent_settings.ts:1263",
@@ -69,6 +63,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 
 // src/scripts/_lib/settings_renamed_keys.ts
+var SETTINGS_REMOVAL_RULE = "A settings key may be removed or renamed in a minor release only when no consumer project can rely on it \u2014 default-neutral and derivable, proven by a named test; any other removal or rename ships only in a major, and a renamed key's alias is dropped only in a major.";
 var RENAMED_KEYS = /* @__PURE__ */ new Map([
   ["planning.challenge_on_create", "planning.closure_pass"]
 ]);
@@ -99,7 +94,7 @@ function applyRenamedKeys(layer) {
     if (_warned.has(oldKey)) continue;
     _warned.add(oldKey);
     process.stderr.write(
-      `\u26A0\uFE0F  settings: \`${oldKey}\` was renamed to \`${newKey}\`. The old key still works for one minor; rename it in your .agent-settings.yml.
+      `\u26A0\uFE0F  settings: \`${oldKey}\` was renamed to \`${newKey}\`; the old key still works. ${SETTINGS_REMOVAL_RULE} Rename it in your .agent-settings.yml.
 `
     );
   }
@@ -175,7 +170,11 @@ var REMOVED_KEYS = /* @__PURE__ */ new Map([
   ["pipelines.skill_improvement", "the skill-improvement-trigger rule; the capture is a proposal the user confirms"],
   ["consistency.cross_source", "the cross-source-consistency rule, always on; batching and the no-cheap-questions floor bound the noise"],
   ["subagents.downshift", "the model_tier each sub-task declares; downshift is always on"],
-  ["ai_team.suppress_setup_hint", "nothing: the one-line team-mode setup hint is always shown"]
+  ["ai_team.suppress_setup_hint", "nothing: the one-line team-mode setup hint is always shown"],
+  // 2026-10-20 — the projection keys (ADR-293, road-to-a-setup-that-decides-itself Phase 4)
+  ["lean_projection.mode", "the computed layer-form decision (_lib/layer_form_decision.ts), plus `install --full` and src/config/layer-form-brakes.json as the two brakes. For one release window an installer converts a leftover `eager-all` into the install receipt pin and drops any other value, saying which (_lib/projection_key_migration.ts); the project tree reads the package-owned src/config/project-tree-form.json, never this key"],
+  ["lean_projection.hosts", "THINNABLE_HOSTS in _lib/lean_projection_mode.ts and the per-host row in src/config/host-injection-effect.json; no reader of this key remains"],
+  ["projection.rule_workspaces", "consumerRuleWorkspaces() in _lib/scoped_projection.ts, which derives the consumer workspace set from src/config/discovery/packs.yml \u2014 every id minus `agent-config-maintainer` \u2014 so a new pack reaches consumers without a settings edit"]
 ]);
 var _warnedRemovedKeys = /* @__PURE__ */ new Set();
 function _readDotted(root, dotted) {
@@ -312,17 +311,12 @@ var MERGEABLE_KEYS = [
   // GUI; whitelisting decides only whether the value SURVIVES the merge
   // (ADR-271, road-to-design-intent-conformance 2.3).
   "design.fidelity_mode",
-  // `lean_projection.*` is a per-MACHINE setting and the install it governs is
-  // a user-scope one: the layer being thinned is `~/.claude/rules`, which
-  // belongs to the machine and not to any checkout. Without these two rows a
-  // consumer who wrote the opt-in into the user-global file got no error, no
-  // warning and no effect — the same silent-filter defect the two entries
-  // above repair, reaching a third key, and unsatisfiable-by-construction on
-  // an ADR-020 global-only install, where no project layer exists to carry it.
-  // Whitelisting decides only whether a value SURVIVES the merge: it sets
-  // nothing, and `installerThinsHost` still refuses a template-only value.
-  "lean_projection.mode",
-  "lean_projection.hosts"
+  // `retro.enabled` is the one switch over the automatic retro (ADR-292). It
+  // ships `true`, so the only value worth writing is `false`, and a user who
+  // writes it once in the user-global file expects every checkout without its
+  // own value to honour it — without this row the off switch would be
+  // discarded silently. A project value still wins.
+  "retro.enabled"
 ];
 var TEMPLATE_RELATIVE = path.join("src", "config", "agent-settings.template.yml");
 var _PACKAGE_ROOT = resolvePackageRoot(import.meta.url);
@@ -832,6 +826,7 @@ export {
   ROOT_OVERRIDE_ENV,
   ProjectRootError,
   resolve_project_root,
+  _resolve_cascade_paths,
   settings_layer_states,
   load_agent_settings,
   iter_setting_overrides

package/dist/cli-delegate/{chunk-6YQC2HLF.js → chunk-YHAPONWV.js}

@@ -1,7 +1,9 @@
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
 import {
-  atomicAppendLine
-} from "./chunk-MDPPKQCQ.js";
+  atomicAppendLine,
+  readConsequenceClass,
+  stubLawIds
+} from "./chunk-QBHEI5N4.js";
 
 // src/install/txlog.ts
 import { createGzip } from "node:zlib";
@@ -95,8 +97,8 @@ function tryParseEntry(line) {
 
 // src/scripts/_lib/thin_rules.ts
 import { createHash } from "node:crypto";
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/scripts/_lib/rule_law_section.ts
@@ -157,23 +159,6 @@ function lawText(body) {
   return sections.map((s) => s.text).join("\n\n");
 }
 
-// src/scripts/_lib/rule_consequence_class.ts
-import * as fs from "node:fs";
-import * as path from "node:path";
-var CLASS_CONFIG_REL = "src/config/rule-consequence-class.json";
-function readConsequenceClass(repoRoot) {
-  const raw = JSON.parse(fs.readFileSync(path.join(repoRoot, CLASS_CONFIG_REL), "utf-8"));
-  return {
-    criterion_ref: raw.criterion_ref ?? "",
-    members: raw.members ?? {},
-    no_stub: raw.no_stub ?? {},
-    excluded: raw.excluded ?? {}
-  };
-}
-function stubLawIds(cfg) {
-  return new Set(Object.keys(cfg.members).filter((id) => cfg.no_stub[id] === void 0));
-}
-
 // src/scripts/_lib/rule_injection.ts
 var PATH_TRIGGER_KINDS = ["path_prefix", "file_pattern"];
 function tierEntries(router, tier) {
@@ -208,22 +193,22 @@ function triggerlessRuleIds(router) {
 
 // src/scripts/_lib/thin_rules.ts
 var _HERE = fileURLToPath(import.meta.url);
-var REPO_ROOT = path2.resolve(path2.dirname(_HERE), "..", "..", "..");
-var RULES_SOURCE = path2.join(REPO_ROOT, "dist/agent-src", "rules");
-var ROUTER = path2.join(REPO_ROOT, "dist", "router.json");
+var REPO_ROOT = path.resolve(path.dirname(_HERE), "..", "..", "..");
+var RULES_SOURCE = path.join(REPO_ROOT, "dist/agent-src", "rules");
+var ROUTER = path.join(REPO_ROOT, "dist", "router.json");
 function _globSortedMd(dir) {
   let names;
   try {
-    names = fs2.readdirSync(dir);
+    names = fs.readdirSync(dir);
   } catch {
     return [];
   }
-  const out = names.filter((n) => n.endsWith(".md")).map((n) => path2.join(dir, n));
+  const out = names.filter((n) => n.endsWith(".md")).map((n) => path.join(dir, n));
   out.sort();
   return out;
 }
 function kernel_ids(routerPath = ROUTER) {
-  const data = JSON.parse(fs2.readFileSync(routerPath, "utf-8"));
+  const data = JSON.parse(fs.readFileSync(routerPath, "utf-8"));
   const kernel = data.kernel;
   if (Array.isArray(kernel)) {
     return new Set(kernel.map((x) => String(x)));
@@ -231,7 +216,7 @@ function kernel_ids(routerPath = ROUTER) {
   return /* @__PURE__ */ new Set();
 }
 function _router(routerPath = ROUTER) {
-  return JSON.parse(fs2.readFileSync(routerPath, "utf-8"));
+  return JSON.parse(fs.readFileSync(routerPath, "utf-8"));
 }
 function path_only_ids(routerPath = ROUTER) {
   return pathOnlyRuleIds(_router(routerPath));
@@ -240,7 +225,7 @@ function no_trigger_ids(routerPath = ROUTER) {
   return new Set(triggerlessRuleIds(_router(routerPath)));
 }
 function rule_workspaces_map(routerPath = ROUTER) {
-  const data = JSON.parse(fs2.readFileSync(routerPath, "utf-8"));
+  const data = JSON.parse(fs.readFileSync(routerPath, "utf-8"));
   const map = /* @__PURE__ */ new Map();
   for (const tier of ["tier_1", "tier_2"]) {
     const entries = data[tier];
@@ -312,7 +297,7 @@ var THIN_BODY_POINTER_RE = (() => {
 })();
 var BODY_LINK_PREFIX = "../../dist/agent-src/rules/";
 function absoluteBodyLinkPrefix(packageRoot) {
-  return `${path2.join(path2.resolve(packageRoot), "dist", "agent-src", "rules")}${path2.sep}`;
+  return `${path.join(path.resolve(packageRoot), "dist", "agent-src", "rules")}${path.sep}`;
 }
 function thin_entry(rule_id, text, bodyLinkPrefix = BODY_LINK_PREFIX) {
   const [fm] = split_frontmatter(text);
@@ -359,7 +344,7 @@ ${STUB_LAW_CLOSE}
 `;
 }
 function build_thin(rules_dir = RULES_SOURCE, scope = null, announce = null, consequenceClass = null, roots = null) {
-  const routerPath = roots?.routerPath ?? (roots?.packageRoot === void 0 ? ROUTER : path2.join(roots.packageRoot, "dist", "router.json"));
+  const routerPath = roots?.routerPath ?? (roots?.packageRoot === void 0 ? ROUTER : path.join(roots.packageRoot, "dist", "router.json"));
   const classRoot = roots?.packageRoot ?? REPO_ROOT;
   const bodyLinkPrefix = roots?.bodyLinkPrefix ?? BODY_LINK_PREFIX;
   const kernel = kernel_ids(routerPath);
@@ -370,39 +355,65 @@ function build_thin(rules_dir = RULES_SOURCE, scope = null, announce = null, con
   const wsMap = scope !== null ? rule_workspaces_map(routerPath) : /* @__PURE__ */ new Map();
   const out = /* @__PURE__ */ new Map();
   for (const p of _globSortedMd(rules_dir)) {
-    const text = fs2.readFileSync(p, "utf-8");
-    const stem = path2.basename(p).replace(/\.md$/, "");
+    const text = fs.readFileSync(p, "utf-8");
+    const stem = path.basename(p).replace(/\.md$/, "");
     if (!id_in_scope(stem, scope, kernel, wsMap, fm_workspaces(text))) {
       continue;
     }
     const noStub = cls.no_stub[stem] !== void 0;
     const full = kernel.has(stem) || noTrigger.has(stem) || pathOnly.has(stem) || noStub;
     if (announce !== null && noTrigger.has(stem) && !kernel.has(stem)) {
-      announce(`D3: trigger-less auto rule ${path2.basename(p)} \u2014 kept full-bodied, never thinned`);
+      announce(`D3: trigger-less auto rule ${path.basename(p)} \u2014 kept full-bodied, never thinned`);
     }
     if (announce !== null && pathOnly.has(stem) && !kernel.has(stem) && !noTrigger.has(stem)) {
       announce(
-        `E2: path-only auto rule ${path2.basename(p)} \u2014 kept full-bodied; its only triggers are path-shaped and the delivery concern is not bound on pre_tool_use`
+        `E2: path-only auto rule ${path.basename(p)} \u2014 kept full-bodied; its only triggers are path-shaped and the delivery concern is not bound on pre_tool_use`
       );
     }
     if (full) {
-      out.set(path2.basename(p), text);
+      out.set(path.basename(p), text);
       continue;
     }
     if (lawInStub.has(stem)) {
       if (announce !== null) {
         announce(
-          `LAW: high-consequence rule ${path2.basename(p)} \u2014 stub carries its own law section, byte-copied`
+          `LAW: high-consequence rule ${path.basename(p)} \u2014 stub carries its own law section, byte-copied`
         );
       }
-      out.set(path2.basename(p), thin_entry_with_law(stem, text, bodyLinkPrefix));
+      out.set(path.basename(p), thin_entry_with_law(stem, text, bodyLinkPrefix));
       continue;
     }
-    out.set(path2.basename(p), thin_entry(stem, text, bodyLinkPrefix));
+    out.set(path.basename(p), thin_entry(stem, text, bodyLinkPrefix));
   }
   return out;
 }
 
+// src/scripts/_lib/model_tier.ts
+import fs2 from "node:fs";
+var TIER_TO_CLAUDE_MODEL = {
+  frontier: "fable",
+  high: "opus",
+  medium: "sonnet",
+  lite: "haiku"
+};
+var MODEL_TIER_RE = /^model_tier:\s*"?([a-z]+)"?\s*$/m;
+function read_model_tier(skill_md) {
+  if (!fs2.existsSync(skill_md)) return null;
+  const text = fs2.readFileSync(skill_md).toString("utf-8");
+  if (!text.startsWith("---\n")) return null;
+  const end = text.indexOf("\n---\n", 4);
+  if (end === -1) return null;
+  const m = MODEL_TIER_RE.exec(text.slice(4, end));
+  return m ? m[1] : null;
+}
+function render_native_model_md(text, tier) {
+  const model = TIER_TO_CLAUDE_MODEL[tier];
+  if (model === void 0) {
+    throw new Error(`'${tier}'`);
+  }
+  return text.replace(MODEL_TIER_RE, `model: ${model}`);
+}
+
 export {
   appendTxLog,
   readRecentEntries,
@@ -411,5 +422,8 @@ export {
   split_frontmatter,
   THIN_ENTRY_MARKER,
   absoluteBodyLinkPrefix,
-  build_thin
+  build_thin,
+  TIER_TO_CLAUDE_MODEL,
+  read_model_tier,
+  render_native_model_md
 };