@event4u/agent-config 9.9.0 → 9.11.0

package/dist/cli-delegate/cmd_explain.js

@@ -0,0 +1,2508 @@
+#!/usr/bin/env tsx
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  StateLoadError,
+  load_state
+} from "./chunk-GME3Q44L.js";
+import {
+  artefact_roots
+} from "./chunk-BJGXZNPM.js";
+import {
+  DEFAULT_PROJECT_FILE,
+  ProjectRootError,
+  load_agent_settings,
+  logger,
+  resolve_project_root
+} from "./chunk-HJ6DAJHR.js";
+import "./chunk-NDJLNC6Q.js";
+import {
+  __export
+} from "./chunk-J55WI3RR.js";
+
+// src/scripts/_cli/cmd_explain.ts
+import * as fs8 from "node:fs";
+import * as path7 from "node:path";
+import process2 from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// src/scripts/config/presets.ts
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+var _require = createRequire(import.meta.url);
+var PRESET_ID_ENV = "AGENT_CONFIG_PRESET_ID";
+var DEFAULT_PRESET_ID = "balanced";
+var PRESETS_DIRNAME = ".agent-src.uncondensed/presets";
+var SOURCE_PACK = "pack";
+var SOURCE_PROFILE = "profile";
+var SOURCE_USER = "user-settings";
+var SOURCE_ENV = "env";
+var SOURCE_RUNTIME = "runtime";
+var SOURCE_DEFAULT = "default";
+var ENV_KNOB_MAP = {
+  AGENT_CONFIG_PRESET_COST_DAILY_MAX_USD: ["cost", "daily_max_usd"],
+  AGENT_CONFIG_PRESET_COST_WEEKLY_MAX_USD: ["cost", "weekly_max_usd"],
+  AGENT_CONFIG_PRESET_COST_MONTHLY_MAX_USD: ["cost", "monthly_max_usd"],
+  AGENT_CONFIG_PRESET_MCP_PER_CALL_MAX_USD: ["mcp", "per_call_max_usd"],
+  AGENT_CONFIG_PRESET_MCP_PER_SESSION_MAX_USD: ["mcp", "per_session_max_usd"],
+  AGENT_CONFIG_PRESET_COUNCIL_CAP_PER_CONSULT_USD: ["council", "cap_per_consult_usd"],
+  AGENT_CONFIG_PRESET_AUTONOMY_DEFAULT: ["autonomy", "default"],
+  AGENT_CONFIG_PRESET_CONFIDENCE_MIN_BAND: ["confidence", "min_band"]
+};
+var ResolvedPreset = class {
+  id;
+  knobs;
+  source;
+  overrides;
+  warning;
+  constructor(params) {
+    this.id = params.id;
+    this.knobs = params.knobs ?? {};
+    this.source = params.source ?? SOURCE_DEFAULT;
+    this.overrides = params.overrides ?? [];
+    this.warning = params.warning ?? null;
+  }
+};
+var PresetError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PresetError";
+  }
+};
+function _load_yaml(p) {
+  let YAML;
+  try {
+    YAML = _require("yaml");
+  } catch {
+    logger.info("PyYAML unavailable; preset %s returned empty", p);
+    return {};
+  }
+  let text;
+  try {
+    text = fs.readFileSync(p, "utf-8");
+  } catch (exc) {
+    logger.warning("preset read failed for %s: %s", p, String(exc));
+    return {};
+  }
+  let data;
+  try {
+    data = YAML.parse(text, { version: "1.1" });
+    if (data === null || data === void 0) {
+      data = {};
+    }
+  } catch (exc) {
+    logger.warning("preset parse failed for %s: %s", p, String(exc));
+    return {};
+  }
+  return _isPlainDict(data) ? data : {};
+}
+function _preset_file(project_root, preset_id) {
+  const legacy = path.join(project_root, PRESETS_DIRNAME, `${preset_id}.yml`);
+  if (_exists(legacy)) {
+    return legacy;
+  }
+  let roots;
+  try {
+    roots = artefact_roots();
+  } catch {
+    return legacy;
+  }
+  for (const root of roots) {
+    const candidate = path.join(root, "presets", `${preset_id}.yml`);
+    if (_exists(candidate)) {
+      return candidate;
+    }
+  }
+  return legacy;
+}
+function _coerce_scalar(raw) {
+  const asInt = _pyInt(raw);
+  if (asInt !== null) {
+    return asInt;
+  }
+  const asFloat = _pyFloat(raw);
+  if (asFloat !== null) {
+    return asFloat;
+  }
+  const lowered = raw.toLowerCase();
+  if (lowered === "true" || lowered === "false") {
+    return lowered === "true";
+  }
+  return raw;
+}
+function _deep_merge(base, override) {
+  const paths = [];
+  function walk(b, o, prefix) {
+    for (const key of Object.keys(o)) {
+      const value = o[key];
+      const dotted = `${prefix}${key}`;
+      if (_isPlainDict(value) && _isPlainDict(b[key])) {
+        walk(b[key], value, `${dotted}.`);
+      } else {
+        b[key] = _deepCopy(value);
+        paths.push(dotted);
+      }
+    }
+  }
+  walk(base, override, "");
+  return paths;
+}
+function _pick_id(pack_preset_id, profile_preset_id, user_settings, runtime_id) {
+  if (runtime_id) {
+    return [runtime_id, SOURCE_RUNTIME];
+  }
+  const env_id = process.env[PRESET_ID_ENV];
+  if (env_id) {
+    return [env_id, SOURCE_ENV];
+  }
+  const block = _isPlainDict(user_settings) ? user_settings["preset"] : void 0;
+  if (_isPlainDict(block) && block["id"]) {
+    return [String(block["id"]), SOURCE_USER];
+  }
+  if (pack_preset_id) {
+    return [pack_preset_id, SOURCE_PACK];
+  }
+  if (profile_preset_id) {
+    return [profile_preset_id, SOURCE_PROFILE];
+  }
+  return [null, SOURCE_DEFAULT];
+}
+function resolve_preset(params) {
+  const settings = params.user_settings ?? {};
+  let [preset_id, source] = _pick_id(
+    params.pack_preset_id ?? null,
+    params.profile_preset_id ?? null,
+    settings,
+    params.runtime_id ?? null
+  );
+  if (preset_id === null) {
+    preset_id = DEFAULT_PRESET_ID;
+    source = SOURCE_DEFAULT;
+  }
+  const yaml_path = _preset_file(params.project_root, preset_id);
+  if (!_exists(yaml_path)) {
+    throw new PresetError(
+      `preset.id=${_repr(preset_id)} (${source}) but ${yaml_path} not found`
+    );
+  }
+  const raw = _load_yaml(yaml_path);
+  let knobs = raw["preset"] ?? {};
+  if (!_isPlainDict(knobs)) {
+    throw new PresetError(`${yaml_path} has no top-level 'preset:' mapping`);
+  }
+  knobs = _deepCopy(knobs);
+  delete knobs["id"];
+  const overrides = [];
+  const settingsPreset = settings["preset"];
+  const user_block = _isPlainDict(settingsPreset) ? settingsPreset : null;
+  if (_isPlainDict(user_block)) {
+    const user_overrides = {};
+    for (const k of Object.keys(user_block)) {
+      if (k !== "id") {
+        user_overrides[k] = user_block[k];
+      }
+    }
+    if (Object.keys(user_overrides).length > 0) {
+      overrides.push(..._deep_merge(knobs, user_overrides));
+    }
+  }
+  for (const env_key of Object.keys(ENV_KNOB_MAP)) {
+    const keyPath = ENV_KNOB_MAP[env_key];
+    const raw_value = process.env[env_key];
+    if (raw_value === void 0) {
+      continue;
+    }
+    let cursor = knobs;
+    for (const part of keyPath.slice(0, -1)) {
+      if (!_isPlainDict(cursor[part])) {
+        cursor[part] = {};
+      }
+      cursor = cursor[part];
+    }
+    cursor[keyPath[keyPath.length - 1]] = _coerce_scalar(raw_value);
+    overrides.push(keyPath.join("."));
+  }
+  if (params.runtime_overrides) {
+    for (const [keyPath, value] of params.runtime_overrides) {
+      let cursor = knobs;
+      for (const part of keyPath.slice(0, -1)) {
+        if (!_isPlainDict(cursor[part])) {
+          cursor[part] = {};
+        }
+        cursor = cursor[part];
+      }
+      cursor[keyPath[keyPath.length - 1]] = value;
+      overrides.push(keyPath.join("."));
+    }
+  }
+  return new ResolvedPreset({
+    id: preset_id,
+    knobs,
+    source,
+    overrides
+  });
+}
+function _exists(p) {
+  try {
+    fs.statSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function _isPlainDict(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Map);
+}
+function _deepCopy(value) {
+  if (Array.isArray(value)) {
+    return value.map((v) => _deepCopy(v));
+  }
+  if (_isPlainDict(value)) {
+    const out = {};
+    for (const k of Object.keys(value)) {
+      out[k] = _deepCopy(value[k]);
+    }
+    return out;
+  }
+  return value;
+}
+function _pyInt(raw) {
+  const s = raw.trim();
+  if (!/^[+-]?\d+(?:_\d+)*$/.test(s)) {
+    return null;
+  }
+  const n = Number(s.replace(/_/g, ""));
+  return Number.isFinite(n) ? n : null;
+}
+function _pyFloat(raw) {
+  const s = raw.trim();
+  if (s === "") {
+    return null;
+  }
+  const lowered = s.toLowerCase().replace("+", "").replace("-", "");
+  if (lowered === "inf" || lowered === "infinity") {
+    return s.trim().startsWith("-") ? -Infinity : Infinity;
+  }
+  if (lowered === "nan") {
+    return NaN;
+  }
+  if (!/^[+-]?(?:\d+(?:_\d+)*\.?\d*(?:_\d+)*|\.\d+(?:_\d+)*)(?:[eE][+-]?\d+)?$/.test(s)) {
+    return null;
+  }
+  const n = Number(s.replace(/_/g, ""));
+  return Number.isFinite(n) ? n : null;
+}
+function _repr(s) {
+  return `'${s.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+
+// src/scripts/config/profiles.ts
+import * as fs2 from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import * as path2 from "node:path";
+var _require2 = createRequire2(import.meta.url);
+var PROFILE_ID_ENV = "AGENT_CONFIG_PROFILE_ID";
+var DEFAULT_PROFILE_ID = "developer";
+var PROFILES_DIRNAME = ".agent-src.uncondensed/profiles";
+var SOURCE_PACK2 = "pack";
+var SOURCE_USER2 = "user-settings";
+var SOURCE_ENV2 = "env";
+var SOURCE_RUNTIME2 = "runtime";
+var SOURCE_DEFAULT2 = "default";
+var SOURCE_MISSING = "missing";
+var ResolvedProfile = class {
+  id;
+  audience;
+  preset_id;
+  packs;
+  personas;
+  skills_hint;
+  commands_hint;
+  docs_first_pointer;
+  source;
+  warning;
+  constructor(params) {
+    this.id = params.id;
+    this.audience = params.audience ?? {};
+    this.preset_id = params.preset_id ?? null;
+    this.packs = params.packs ?? [];
+    this.personas = params.personas ?? [];
+    this.skills_hint = params.skills_hint ?? [];
+    this.commands_hint = params.commands_hint ?? [];
+    this.docs_first_pointer = params.docs_first_pointer ?? null;
+    this.source = params.source ?? SOURCE_DEFAULT2;
+    this.warning = params.warning ?? null;
+  }
+};
+var ProfileError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ProfileError";
+  }
+};
+function _load_yaml2(p) {
+  let YAML;
+  try {
+    YAML = _require2("yaml");
+  } catch {
+    logger.info("PyYAML unavailable; profile %s returned empty", p);
+    return {};
+  }
+  let text;
+  try {
+    text = fs2.readFileSync(p, "utf-8");
+  } catch (exc) {
+    logger.warning("profile read failed for %s: %s", p, String(exc));
+    return {};
+  }
+  let data;
+  try {
+    data = YAML.parse(text, { version: "1.1" });
+    if (data === null || data === void 0) {
+      data = {};
+    }
+  } catch (exc) {
+    logger.warning("profile parse failed for %s: %s", p, String(exc));
+    return {};
+  }
+  return _isPlainDict2(data) ? data : {};
+}
+function _profile_file(project_root, profile_id) {
+  const legacy = path2.join(project_root, PROFILES_DIRNAME, `${profile_id}.yml`);
+  if (_exists2(legacy)) {
+    return legacy;
+  }
+  let roots;
+  try {
+    roots = artefact_roots();
+  } catch {
+    return legacy;
+  }
+  for (const root of roots) {
+    const candidate = path2.join(root, "profiles", `${profile_id}.yml`);
+    if (_exists2(candidate)) {
+      return candidate;
+    }
+  }
+  return legacy;
+}
+function _build_resolved(profile_id, raw, options) {
+  const block = _isPlainDict2(raw["profile"]) ? raw["profile"] : {};
+  const audience_raw = _isPlainDict2(block["audience"]) ? block["audience"] : {};
+  const defaults = _isPlainDict2(block["defaults"]) ? block["defaults"] : {};
+  const surface = _isPlainDict2(block["surface"]) ? block["surface"] : {};
+  const audience = {};
+  for (const k of Object.keys(audience_raw)) {
+    audience[String(k)] = String(audience_raw[k]);
+  }
+  const packs = _strTuple(block["packs"]);
+  const personas = _strTuple(defaults["personas"]);
+  const skills_hint = _strTuple(defaults["skills_hint"]);
+  const commands_hint = _strTuple(surface["commands_hint"]);
+  const docs_pointer = surface["docs_first_pointer"];
+  return new ResolvedProfile({
+    id: profile_id,
+    audience,
+    preset_id: defaults["preset_id"] ?? null,
+    packs,
+    personas,
+    skills_hint,
+    commands_hint,
+    docs_first_pointer: docs_pointer ? String(docs_pointer) : null,
+    source: options.source,
+    warning: options.warning ?? null
+  });
+}
+function _pick_id2(pack_profile_id, user_settings, runtime_id) {
+  if (runtime_id) {
+    return [runtime_id, SOURCE_RUNTIME2];
+  }
+  const env_id = process.env[PROFILE_ID_ENV];
+  if (env_id) {
+    return [env_id, SOURCE_ENV2];
+  }
+  const block = _isPlainDict2(user_settings) ? user_settings["profile"] : void 0;
+  if (_isPlainDict2(block) && block["id"]) {
+    return [String(block["id"]), SOURCE_USER2];
+  }
+  if (pack_profile_id) {
+    return [pack_profile_id, SOURCE_PACK2];
+  }
+  return [null, SOURCE_MISSING];
+}
+function resolve_profile(params) {
+  const settings = params.user_settings ?? {};
+  const settings_file = path2.join(params.project_root, DEFAULT_PROJECT_FILE);
+  const [profile_id, source] = _pick_id2(
+    params.pack_profile_id ?? null,
+    settings,
+    params.runtime_id ?? null
+  );
+  if (profile_id === null) {
+    if (_exists2(settings_file)) {
+      return new ResolvedProfile({
+        id: DEFAULT_PROFILE_ID,
+        source: SOURCE_MISSING,
+        warning: "no profile.id in .agent-settings.yml \u2014 run /onboard to pick an audience deliberately"
+      });
+    }
+    return _build_resolved(
+      DEFAULT_PROFILE_ID,
+      _load_yaml2(_profile_file(params.project_root, DEFAULT_PROFILE_ID)),
+      { source: SOURCE_DEFAULT2 }
+    );
+  }
+  const yaml_path = _profile_file(params.project_root, profile_id);
+  if (!_exists2(yaml_path)) {
+    throw new ProfileError(
+      `profile.id=${_repr2(profile_id)} (${source}) but ${yaml_path} not found`
+    );
+  }
+  return _build_resolved(profile_id, _load_yaml2(yaml_path), { source });
+}
+function _exists2(p) {
+  try {
+    fs2.statSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function _isPlainDict2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Map);
+}
+function _strTuple(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((v) => String(v));
+}
+function _repr2(s) {
+  return `'${s.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+
+// src/scripts/_cli/explain_last/index.ts
+import * as fs7 from "node:fs";
+
+// src/scripts/_cli/explain_last/scrubber.ts
+var LONG_STRING_THRESHOLD = 200;
+var _RAW_KEY_PREFIXES = [
+  "sk_live_",
+  "sk_test_",
+  "ghp_",
+  "github_pat_",
+  "gho_",
+  "ghs_",
+  "ghu_",
+  "xoxb-",
+  "xoxp-",
+  "AIza",
+  "AKIA"
+];
+function _reEscape(literal) {
+  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/-/g, "\\u002d");
+}
+var _W = "\\p{L}\\p{N}_";
+var _RAW_KEY_RE = new RegExp(
+  "(?:" + _RAW_KEY_PREFIXES.map(_reEscape).join("|") + ")[A-Za-z0-9_-]{6,}",
+  "gu"
+);
+var _API_KEY_RE = new RegExp(
+  "\\bapi[_-]?key\\b\\s*[:=]\\s*[A-Za-z0-9+/=_-]{12,}",
+  "giu"
+);
+var _EMAIL_RE = new RegExp(
+  `(?<![${_W}.+-])[${_W}.+-]+@[${_W}-]+\\.[${_W}.-]+(?![${_W}.-])`,
+  "gu"
+);
+var _PATH_RE = new RegExp(
+  `(?:/Users/|/home/|/opt/|/private/|[A-Z]:\\\\)[${_W}./\\\\-]+`,
+  "gu"
+);
+var _URL_RE = new RegExp(
+  "(?<![\\p{L}\\p{N}_])(?<scheme>https?|ftp|ws|wss)://(?<host>[^\\s/:?#]+)(?:[^\\s]*)?",
+  "gu"
+);
+var _INTERNAL_HOST_RE = new RegExp(
+  `(?<![${_W}])[a-zA-Z0-9][${_W}.-]*\\.(?:internal|local)(?![${_W}])`,
+  "giu"
+);
+var _MONEY_RE = new RegExp(
+  "(?:[$\u20AC\xA3\xA5]\\s?\\d{1,3}(?:[,.]\\d{3})*(?:\\.\\d+)?|\\b(?:USD|EUR|GBP|JPY)\\s?\\d+(?:[,.]\\d+)?)",
+  "gu"
+);
+function pyLen(s) {
+  let n = 0;
+  for (const _ch of s) {
+    n += 1;
+  }
+  return n;
+}
+function _stripUrl(_match, scheme, host) {
+  return `${scheme}://${host}/\u2026`;
+}
+function scrub_string(value) {
+  if (typeof value !== "string" || value === "") {
+    return value;
+  }
+  let out = value.replace(_RAW_KEY_RE, "<secret>");
+  out = out.replace(_API_KEY_RE, "api_key=<secret>");
+  out = out.replace(_EMAIL_RE, "<email>");
+  out = out.replace(_URL_RE, _stripUrl);
+  out = out.replace(_PATH_RE, "<path>");
+  out = out.replace(_INTERNAL_HOST_RE, "<host>");
+  out = out.replace(_MONEY_RE, "<money>");
+  if (pyLen(out) > LONG_STRING_THRESHOLD) {
+    return `<${pyLen(out)} chars>`;
+  }
+  return out;
+}
+
+// src/scripts/_cli/explain_last/assumptions.ts
+function _pySlice(s, n) {
+  return Array.from(s).slice(0, n).join("");
+}
+function _pyTruthy(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  if (typeof value === "number") {
+    return value !== 0 && !Number.isNaN(value);
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length > 0;
+  }
+  return true;
+}
+function _normalise(raw, fallback_idx) {
+  if (typeof raw === "string") {
+    const text = raw.trim();
+    if (!text) {
+      return null;
+    }
+    const scrubbed = scrub_string(text);
+    const sliced = typeof scrubbed === "string" ? _pySlice(scrubbed, 120) : scrubbed;
+    return {
+      id: _pyTruthy(sliced) ? sliced : `assumption-${fallback_idx}`,
+      accepted: true,
+      source: "refine"
+    };
+  }
+  if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
+    const r = raw;
+    let ident = _pyTruthy(r.id) ? r.id : _pyTruthy(r.text) ? r.text : `assumption-${fallback_idx}`;
+    if (typeof ident !== "string") {
+      ident = String(ident);
+    }
+    const scrubbed = scrub_string(ident.trim());
+    ident = _pyTruthy(scrubbed) ? scrubbed : `assumption-${fallback_idx}`;
+    const acceptedRaw = "accepted" in r ? r.accepted : true;
+    const accepted = _pyBool(acceptedRaw);
+    const source = _pyTruthy(r.source) ? r.source : _pyTruthy(r.step) ? r.step : "refine";
+    return {
+      id: ident,
+      accepted,
+      source: scrub_string(String(source))
+    };
+  }
+  return null;
+}
+function _pyBool(value) {
+  return _pyTruthy(value);
+}
+function build(state) {
+  const input = _pyTruthy(state.input) ? state.input : {};
+  const dataRaw = input.data;
+  const data = _pyTruthy(dataRaw) ? dataRaw : {};
+  const rawListRaw = data.assumptions;
+  if (!Array.isArray(rawListRaw)) {
+    return [];
+  }
+  const out = [];
+  rawListRaw.forEach((raw, idx) => {
+    const entry = _normalise(raw, idx);
+    if (entry !== null) {
+      out.push(entry);
+    }
+  });
+  return out;
+}
+
+// src/scripts/_cli/explain_last/council.ts
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+var RUN_WINDOW_SECONDS = 3600;
+function _pySlice200(s) {
+  const cps = Array.from(s);
+  return cps.slice(0, 200).join("");
+}
+function _firstLine(s) {
+  const m = s.split(/\r\n|[\n\r\v\f\x1c\x1d\x1e\x85]/);
+  return m.length > 0 ? m[0] : void 0;
+}
+function _candidate_files(project_root) {
+  const sessions_root = path3.join(
+    project_root,
+    "agents",
+    "runtime",
+    "council",
+    "sessions"
+  );
+  const tmp_root = path3.join(project_root, "tmp");
+  const candidates = [];
+  if (_isDir(sessions_root)) {
+    for (const sub of _iterdir(sessions_root)) {
+      if (_isDir(sub)) {
+        const candidate = path3.join(sub, "council-responses.json");
+        if (fs3.existsSync(candidate)) {
+          candidates.push(candidate);
+        }
+      }
+    }
+  }
+  if (fs3.existsSync(tmp_root)) {
+    candidates.push(..._glob(tmp_root, "council-", ".json").sort());
+  }
+  return candidates;
+}
+function _pick_recent(candidates, anchor_mtime) {
+  let best = null;
+  for (const p of candidates) {
+    let mtime;
+    try {
+      mtime = fs3.statSync(p).mtimeMs / 1e3;
+    } catch {
+      continue;
+    }
+    if (Math.abs(mtime - anchor_mtime) > RUN_WINDOW_SECONDS) {
+      continue;
+    }
+    if (best === null || mtime > best[0]) {
+      best = [mtime, p];
+    }
+  }
+  return best ? best[1] : null;
+}
+function _extract_member(entry) {
+  const provider = _pyTruthy2(entry.provider) ? String(entry.provider) : "";
+  const model = _pyTruthy2(entry.model) ? String(entry.model) : "";
+  const parts = [provider, model].filter((p) => p !== "");
+  const member_id = parts.length > 0 ? parts.join("/") : "unknown";
+  const text = entry.text;
+  if (typeof text !== "string" || text.trim() === "") {
+    return null;
+  }
+  const firstLine = _firstLine(text.trim()) ?? "";
+  const verdict = scrub_string(_pySlice200(firstLine));
+  const citations = [];
+  for (const cite of entry.citations ?? []) {
+    if (typeof cite === "string") {
+      citations.push(scrub_string(cite));
+    }
+  }
+  return {
+    member_id: scrub_string(member_id),
+    verdict,
+    citations
+  };
+}
+function build2(project_root, state_file) {
+  let anchor;
+  try {
+    anchor = fs3.statSync(state_file).mtimeMs / 1e3;
+  } catch {
+    return null;
+  }
+  const candidates = _candidate_files(project_root);
+  if (candidates.length === 0) {
+    return null;
+  }
+  const picked = _pick_recent(candidates, anchor);
+  if (picked === null) {
+    return null;
+  }
+  let raw;
+  try {
+    raw = JSON.parse(fs3.readFileSync(picked, "utf-8"));
+  } catch {
+    return null;
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return null;
+  }
+  const members = [];
+  for (const entry of raw.responses ?? []) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+      continue;
+    }
+    const member = _extract_member(entry);
+    if (member !== null) {
+      members.push(member);
+    }
+  }
+  return members.length > 0 ? members : null;
+}
+function _isDir(p) {
+  try {
+    return fs3.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function _iterdir(p) {
+  let names;
+  try {
+    names = fs3.readdirSync(p);
+  } catch {
+    return [];
+  }
+  return names.map((n) => path3.join(p, n));
+}
+function _glob(dir, prefix, suffix) {
+  let names;
+  try {
+    names = fs3.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return names.filter((n) => n.startsWith(prefix) && n.endsWith(suffix)).map((n) => path3.join(dir, n));
+}
+function _pyTruthy2(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  if (typeof value === "number") {
+    return value !== 0 && !Number.isNaN(value);
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length > 0;
+  }
+  return true;
+}
+
+// src/scripts/_cli/explain_last/halt.ts
+function _pyTruthy3(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  if (typeof value === "number") {
+    return value !== 0 && !Number.isNaN(value);
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length > 0;
+  }
+  return true;
+}
+function build3(state) {
+  const haltsRaw = _pyTruthy3(state.halts) ? state.halts : [];
+  if (!Array.isArray(haltsRaw) || haltsRaw.length === 0) {
+    return null;
+  }
+  const last = haltsRaw[haltsRaw.length - 1];
+  if (typeof last !== "object" || last === null || Array.isArray(last)) {
+    return null;
+  }
+  const lastDict = last;
+  const reason = lastDict.reason;
+  if (typeof reason !== "string" || !reason) {
+    return null;
+  }
+  const step = lastDict.step;
+  const surfaceRaw = _pyTruthy3(lastDict.surface) ? lastDict.surface : [];
+  const scrubbed_surface = [];
+  if (Array.isArray(surfaceRaw)) {
+    for (const line of surfaceRaw) {
+      if (typeof line === "string") {
+        scrubbed_surface.push(scrub_string(line));
+      }
+    }
+  }
+  return {
+    reason: scrub_string(reason),
+    step: typeof step === "string" && step ? scrub_string(step) : "",
+    surface: scrubbed_surface
+  };
+}
+
+// src/scripts/_cli/explain_last/inputs.ts
+import { createRequire as createRequire3 } from "node:module";
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
+var _require3 = createRequire3(import.meta.url);
+var _DEFAULT_RULE_LOADING_TIER = "balanced";
+var _SILENCED_LOGGERS = [
+  "scripts.config.profiles",
+  "scripts.config.presets"
+];
+function _silence_resolver_warnings(body) {
+  void _SILENCED_LOGGERS;
+  void logger;
+  return body();
+}
+function _load_settings(project_root) {
+  const p = path4.join(project_root, DEFAULT_PROJECT_FILE);
+  if (!fs4.existsSync(p)) {
+    return {};
+  }
+  return load_agent_settings({ project_path: p }) ?? {};
+}
+function _pyTruthy4(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  if (typeof value === "number") {
+    return value !== 0;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length > 0;
+  }
+  return true;
+}
+function build4(project_root) {
+  let resolved_profile;
+  let resolved_preset;
+  let settings;
+  try {
+    const result = _silence_resolver_warnings(() => {
+      const s = _load_settings(project_root);
+      const rp = resolve_profile({
+        project_root,
+        user_settings: s
+      });
+      const rpre = resolve_preset({
+        project_root,
+        user_settings: s,
+        profile_preset_id: rp.preset_id
+      });
+      return { settings: s, resolved_profile: rp, resolved_preset: rpre };
+    });
+    settings = result.settings;
+    resolved_profile = result.resolved_profile;
+    resolved_preset = result.resolved_preset;
+  } catch (exc) {
+    if (exc instanceof ProfileError || exc instanceof PresetError || _isOsError(exc)) {
+      return null;
+    }
+    throw exc;
+  }
+  const isDict = typeof settings === "object" && settings !== null;
+  let rule_loading_tier;
+  if (isDict) {
+    const primary = settings.rule_loading_tier ?? null;
+    rule_loading_tier = _pyTruthy4(primary) ? primary : settings.cost_profile ?? null;
+  } else {
+    rule_loading_tier = null;
+  }
+  let rule_loading_tier_source = _pyTruthy4(rule_loading_tier) ? "user" : "default";
+  if (!_pyTruthy4(rule_loading_tier) || rule_loading_tier === "__RULE_LOADING_TIER__") {
+    rule_loading_tier = _DEFAULT_RULE_LOADING_TIER;
+    rule_loading_tier_source = "default";
+  }
+  return {
+    profile: scrub_string(resolved_profile.id),
+    preset: scrub_string(resolved_preset.id),
+    rule_loading_tier: scrub_string(String(rule_loading_tier)),
+    source_per_knob: {
+      profile: resolved_profile.source,
+      preset: resolved_preset.source,
+      rule_loading_tier: rule_loading_tier_source
+    }
+  };
+}
+function _pack_marker(project_root) {
+  for (const candidate of [
+    path4.join(project_root, ".agent-pack.yml"),
+    path4.join(project_root, ".agent-src.uncondensed", ".agent-pack.yml")
+  ]) {
+    if (fs4.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function build_pack(project_root) {
+  const marker = _pack_marker(project_root);
+  if (marker === null) {
+    return null;
+  }
+  let YAML;
+  try {
+    YAML = _require3("yaml");
+  } catch {
+    return null;
+  }
+  let raw;
+  try {
+    const text = fs4.readFileSync(marker, "utf-8");
+    raw = YAML.parse(text, { version: "1.1" });
+    if (raw === null || raw === void 0) {
+      raw = {};
+    }
+  } catch {
+    return null;
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return null;
+  }
+  const rawDict = raw;
+  const pack_id = _pyTruthy4(rawDict.id) ? rawDict.id : rawDict.pack ?? null;
+  if (typeof pack_id !== "string" || pack_id.trim() === "") {
+    return null;
+  }
+  const reasonRaw = _pyTruthy4(rawDict.reason) ? rawDict.reason : `declared in ${path4.basename(marker)}`;
+  return {
+    id: scrub_string(pack_id.trim()),
+    reason: scrub_string(String(reasonRaw))
+  };
+}
+function _isOsError(exc) {
+  return exc instanceof Error && typeof exc.code === "string";
+}
+
+// src/scripts/_cli/explain_last/memory.ts
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
+var PyFloat = class {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+};
+var MEMORY_SIDECAR = path5.join(".agent-memory", "hits.jsonl");
+function _pyTruthy5(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  if (typeof value === "number") {
+    return value !== 0 && !Number.isNaN(value);
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length > 0;
+  }
+  return true;
+}
+function _coerceFloat(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "boolean") {
+    return value ? 1 : 0;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "") {
+      return null;
+    }
+    const lowered = trimmed.toLowerCase();
+    if (["inf", "infinity", "+inf", "+infinity"].includes(lowered)) {
+      return Infinity;
+    }
+    if (["-inf", "-infinity"].includes(lowered)) {
+      return -Infinity;
+    }
+    if (["nan", "+nan", "-nan"].includes(lowered)) {
+      return NaN;
+    }
+    if (!/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(trimmed)) {
+      return null;
+    }
+    const n = Number(trimmed);
+    return Number.isNaN(n) ? null : n;
+  }
+  return null;
+}
+function _coerce_entry(raw) {
+  const entry_id = _pyTruthy5(raw.entry_id) ? raw.entry_id : raw.id ?? null;
+  if (typeof entry_id !== "string" || entry_id.trim() === "") {
+    return null;
+  }
+  let hitRaw = raw.hit_score ?? null;
+  if (hitRaw === null || hitRaw === void 0) {
+    hitRaw = "score" in raw ? raw.score : 0;
+  }
+  const coerced = _coerceFloat(hitRaw);
+  const hit_score = new PyFloat(coerced === null ? 0 : coerced);
+  const used_in = _pyTruthy5(raw.used_in) ? raw.used_in : _pyTruthy5(raw.step) ? raw.step : "unspecified";
+  return {
+    entry_id: scrub_string(entry_id.trim()),
+    hit_score,
+    used_in: scrub_string(String(used_in))
+  };
+}
+function _from_state(state) {
+  const entries = [];
+  for (const raw of state.memory ?? []) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+      continue;
+    }
+    const entry = _coerce_entry(raw);
+    if (entry !== null) {
+      entries.push(entry);
+    }
+  }
+  return entries;
+}
+function _splitlines(s) {
+  if (s === "") {
+    return [];
+  }
+  const breaks = /* @__PURE__ */ new Set([
+    "\n",
+    "\r",
+    "\v",
+    "\f",
+    "",
+    "",
+    "",
+    "\x85",
+    "\u2028",
+    "\u2029"
+  ]);
+  const out = [];
+  let cur = "";
+  for (let i = 0; i < s.length; i += 1) {
+    const ch = s[i];
+    if (ch === "\r" && s[i + 1] === "\n") {
+      out.push(cur);
+      cur = "";
+      i += 1;
+      continue;
+    }
+    if (breaks.has(ch)) {
+      out.push(cur);
+      cur = "";
+      continue;
+    }
+    cur += ch;
+  }
+  if (cur !== "") {
+    out.push(cur);
+  }
+  return out;
+}
+function _from_sidecar(project_root, run_id) {
+  const p = path5.join(project_root, MEMORY_SIDECAR);
+  if (!fs5.existsSync(p)) {
+    return [];
+  }
+  const entries = [];
+  let content;
+  try {
+    content = fs5.readFileSync(p, "utf-8");
+  } catch {
+    return [];
+  }
+  for (let line of _splitlines(content)) {
+    line = line.trim();
+    if (!line) {
+      continue;
+    }
+    let raw;
+    try {
+      raw = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+      continue;
+    }
+    const rawDict = raw;
+    if (run_id) {
+      const got = rawDict.run_id ?? null;
+      if (got !== null && got !== run_id) {
+        continue;
+      }
+    }
+    const entry = _coerce_entry(rawDict);
+    if (entry !== null) {
+      entries.push(entry);
+    }
+  }
+  return entries;
+}
+function build5(project_root, state) {
+  const input = _pyTruthy5(state.input) ? state.input : {};
+  const dataRaw = "data" in input ? input.data : {};
+  const data = typeof dataRaw === "object" && dataRaw !== null && !Array.isArray(dataRaw) ? dataRaw : {};
+  const run_id = data.id;
+  const entries = _from_state(state);
+  entries.push(
+    ..._from_sidecar(project_root, typeof run_id === "string" ? run_id : null)
+  );
+  return entries.length > 0 ? entries : null;
+}
+
+// src/scripts/_cli/explain_last/provider.ts
+function _isDict(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function _extract(state) {
+  const direct = state.video_provider;
+  if (_isDict(direct)) {
+    return direct;
+  }
+  const contract = state.contract;
+  if (_isDict(contract)) {
+    const nested = contract.video_provider;
+    if (_isDict(nested)) {
+      return nested;
+    }
+  }
+  return null;
+}
+function _pyTruthy6(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  if (typeof value === "number") {
+    return value !== 0 && !Number.isNaN(value);
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length > 0;
+  }
+  return true;
+}
+function build6(state) {
+  const ds = state.directive_set;
+  const dsStr = _pyTruthy6(ds) ? ds : "";
+  if (dsStr !== "video") {
+    return null;
+  }
+  const payload = _extract(state);
+  if (payload === null) {
+    return null;
+  }
+  const pid = payload.id;
+  let reason = payload.selection_reason;
+  if (typeof pid !== "string" || !pid) {
+    return null;
+  }
+  if (typeof reason !== "string" || !reason) {
+    reason = "";
+  }
+  return {
+    id: scrub_string(pid),
+    selection_reason: scrub_string(reason)
+  };
+}
+
+// src/scripts/_cli/explain_last/route.ts
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
+var ROUTER_FILENAME = "router.json";
+var ROUTER_RELATIVE = path6.join("dist", ROUTER_FILENAME);
+function _load_router(project_root) {
+  const p = path6.join(project_root, ROUTER_RELATIVE);
+  if (!fs6.existsSync(p)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(fs6.readFileSync(p, "utf-8"));
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function build7(project_root, state) {
+  const router = _load_router(project_root);
+  if (router === null) {
+    return null;
+  }
+  const kernel = [];
+  for (const rid of router.kernel ?? []) {
+    kernel.push(scrub_string(String(rid)));
+  }
+  const tier_1 = [];
+  for (const entry of router.tier_1 ?? []) {
+    if (typeof entry === "object" && entry !== null && !Array.isArray(entry)) {
+      const rid = entry.id;
+      if (typeof rid === "string") {
+        tier_1.push(scrub_string(rid));
+      }
+    }
+  }
+  const persona = state.persona;
+  const persona_str = typeof persona === "string" && persona ? scrub_string(persona) : null;
+  return {
+    matched_rules: tier_1,
+    kernel_rules: kernel,
+    persona: persona_str
+  };
+}
+
+// src/scripts/_cli/explain_last/index.ts
+var TRACE_VERSION = 1;
+var SUBJECT_BY_KIND = {
+  ticket: "implement-ticket",
+  prompt: "work",
+  diff: "work",
+  file: "work"
+};
+function _pyTruthy7(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  if (typeof value === "number") {
+    return value !== 0 && !Number.isNaN(value);
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length > 0;
+  }
+  return true;
+}
+function _derive_subject(state) {
+  const directive_set = _pyTruthy7(state.directive_set) ? state.directive_set : "";
+  if (directive_set === "video") {
+    return "video";
+  }
+  if (directive_set === "council") {
+    return "council";
+  }
+  const input = _pyTruthy7(state.input) ? state.input : {};
+  const kind = input.kind;
+  const key = typeof kind === "string" && kind ? kind : "";
+  const mapped = SUBJECT_BY_KIND[key];
+  return mapped ?? "unknown";
+}
+function _utcIsoFromEpochSeconds(epochSeconds) {
+  const totalMicros = Math.round(epochSeconds * 1e6);
+  const wholeSeconds = Math.floor(totalMicros / 1e6);
+  const micros = totalMicros - wholeSeconds * 1e6;
+  const d = new Date(wholeSeconds * 1e3);
+  const yyyy = String(d.getUTCFullYear()).padStart(4, "0");
+  const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
+  const dd = String(d.getUTCDate()).padStart(2, "0");
+  const hh = String(d.getUTCHours()).padStart(2, "0");
+  const mi = String(d.getUTCMinutes()).padStart(2, "0");
+  const ss = String(d.getUTCSeconds()).padStart(2, "0");
+  let base = `${yyyy}-${mm}-${dd}T${hh}:${mi}:${ss}`;
+  if (micros !== 0) {
+    base += `.${String(micros).padStart(6, "0")}`;
+  }
+  return `${base}+00:00`;
+}
+function _derive_run_id(state, state_file) {
+  const input = _pyTruthy7(state.input) ? state.input : {};
+  const dataRaw = _pyTruthy7(input.data) ? input.data : {};
+  const data = typeof dataRaw === "object" && dataRaw !== null && !Array.isArray(dataRaw) ? dataRaw : {};
+  const raw_id = data.id;
+  if (typeof raw_id === "string" && raw_id.trim()) {
+    return scrub_string(raw_id.trim());
+  }
+  let mtime = 0;
+  try {
+    mtime = fs7.statSync(state_file).mtimeMs / 1e3;
+  } catch {
+    mtime = 0;
+  }
+  return _utcIsoFromEpochSeconds(mtime);
+}
+function build_trace(project_root, state_file, options = {}) {
+  const state = load_state(state_file);
+  const now = options.now ?? null;
+  const generated_at = _utcIsoFromEpochSeconds((now ?? /* @__PURE__ */ new Date()).getTime() / 1e3);
+  return {
+    version: TRACE_VERSION,
+    generated_at,
+    run_id: _derive_run_id(state, state_file),
+    subject: _derive_subject(state),
+    inputs: build4(project_root),
+    route: build7(project_root, state),
+    council: build2(project_root, state_file),
+    memory: build5(project_root, state),
+    pack: build_pack(project_root),
+    assumptions: build(state),
+    halt: build3(state),
+    provider: build6(state)
+  };
+}
+
+// src/scripts/_cli/explain_last/sections/assumptions.ts
+var assumptions_exports2 = {};
+__export(assumptions_exports2, {
+  render: () => render
+});
+function _pyTruthy8(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  if (typeof value === "number") {
+    return value !== 0 && !Number.isNaN(value);
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length > 0;
+  }
+  return true;
+}
+function render(trace) {
+  const out = ["## Assumptions", ""];
+  const items = _pyTruthy8(trace.assumptions) ? trace.assumptions : [];
+  if (items.length === 0) {
+    out.push("- (none captured)");
+    out.push("");
+    return out.join("\n");
+  }
+  for (const itemRaw of items) {
+    const item = itemRaw;
+    const ident = _pyTruthy8(item.id) ? item.id : "(unknown)";
+    const accepted = "accepted" in item ? item.accepted : true;
+    const source = _pyTruthy8(item.source) ? item.source : "unspecified";
+    const marker = accepted ? "[x]" : "[ ]";
+    out.push(`- ${marker} ${ident}  \u2014 recorded in step \`${source}\``);
+  }
+  out.push("");
+  return out.join("\n");
+}
+
+// src/scripts/_cli/explain_last/sections/council.ts
+var council_exports2 = {};
+__export(council_exports2, {
+  render: () => render2
+});
+function _pyTruthy9(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  if (typeof value === "number") {
+    return value !== 0 && !Number.isNaN(value);
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length > 0;
+  }
+  return true;
+}
+function render2(trace) {
+  const out = ["## Council", ""];
+  const members = _pyTruthy9(trace.council) ? trace.council : [];
+  if (members.length === 0) {
+    out.push("(none recorded for this run)");
+    out.push("");
+    return out.join("\n");
+  }
+  for (const memberRaw of members) {
+    const member = memberRaw;
+    const mid = _pyTruthy9(member.member_id) ? member.member_id : "(unknown)";
+    const verdict = _pyTruthy9(member.verdict) ? member.verdict : "(no verdict)";
+    out.push(`### ${mid}`);
+    out.push("");
+    out.push(`> ${verdict}`);
+    const citations = _pyTruthy9(member.citations) ? member.citations : [];
+    if (citations.length > 0) {
+      out.push("");
+      out.push("Citations:");
+      for (const cite of citations) {
+        out.push(`- ${cite}`);
+      }
+    }
+    out.push("");
+  }
+  return out.join("\n");
+}
+
+// src/scripts/_cli/explain_last/sections/halt.ts
+var halt_exports2 = {};
+__export(halt_exports2, {
+  render: () => render3
+});
+function _pyTruthy10(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  if (typeof value === "number") {
+    return value !== 0 && !Number.isNaN(value);
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length > 0;
+  }
+  return true;
+}
+function render3(trace) {
+  const out = ["## Why halted?", ""];
+  const halt = trace.halt;
+  if (!_pyTruthy10(halt)) {
+    out.push("(clean run \u2014 no halt recorded)");
+    out.push("");
+    return out.join("\n");
+  }
+  const h = halt;
+  const reason = _pyTruthy10(h.reason) ? h.reason : "(unknown)";
+  const step = _pyTruthy10(h.step) ? h.step : "(unspecified)";
+  out.push(`- **Reason:** \`${reason}\``);
+  out.push(`- **Hook event:** \`${step}\``);
+  const surface = _pyTruthy10(h.surface) ? h.surface : [];
+  if (surface.length > 0) {
+    out.push("");
+    out.push("Surface emitted to the user:");
+    out.push("");
+    for (const line of surface) {
+      out.push(`  ${line}`);
+    }
+  }
+  out.push("");
+  return out.join("\n");
+}
+
+// src/scripts/_cli/explain_last/sections/header.ts
+var header_exports = {};
+__export(header_exports, {
+  render: () => render4
+});
+function _pyTruthy11(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  if (typeof value === "number") {
+    return value !== 0 && !Number.isNaN(value);
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length > 0;
+  }
+  return true;
+}
+var _SUBJECT_LABELS = {
+  work: "/work",
+  "implement-ticket": "/implement-ticket",
+  council: "/council",
+  video: "/video",
+  unknown: "(unknown)"
+};
+function render4(trace) {
+  const run_id = _pyTruthy11(trace.run_id) ? trace.run_id : "(unknown)";
+  const subject = _pyTruthy11(trace.subject) ? trace.subject : "unknown";
+  const label = Object.prototype.hasOwnProperty.call(_SUBJECT_LABELS, subject) ? _SUBJECT_LABELS[subject] : subject;
+  const started = _pyTruthy11(trace.generated_at) ? trace.generated_at : "";
+  return `# explain last \u2014 run ${run_id}
+
+**Subject:** ${label} \xB7 **Started:** ${started}
+`;
+}
+
+// src/scripts/_cli/explain_last/sections/inputs.ts
+var inputs_exports2 = {};
+__export(inputs_exports2, {
+  render: () => render5
+});
+function _pyTruthy12(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  if (typeof value === "number") {
+    return value !== 0 && !Number.isNaN(value);
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length > 0;
+  }
+  return true;
+}
+function _pyStr(value) {
+  if (typeof value === "boolean") {
+    return value ? "True" : "False";
+  }
+  return String(value);
+}
+function render5(trace) {
+  const out = ["## Why this profile / preset?", ""];
+  const inputs = trace.inputs;
+  if (!_pyTruthy12(inputs)) {
+    out.push("- (none) \u2014 settings could not be resolved");
+    out.push("");
+    return out.join("\n");
+  }
+  const inp = inputs;
+  const sources = _pyTruthy12(inp.source_per_knob) ? inp.source_per_knob : {};
+  const rows = [
+    ["profile.id", inp.profile, sources.profile],
+    ["preset.id", inp.preset, sources.preset],
+    ["rule_loading_tier", inp.rule_loading_tier, sources.rule_loading_tier]
+  ];
+  out.push("| knob | value | source |");
+  out.push("|---|---|---|");
+  for (const [knob, value, source] of rows) {
+    const value_str = value === null || value === void 0 ? "(none)" : _pyStr(value);
+    const source_str = _pyTruthy12(source) ? source : "default";
+    out.push(`| ${knob} | ${value_str} | ${source_str} |`);
+  }
+  out.push("");
+  return out.join("\n");
+}
+
+// src/scripts/_cli/explain_last/sections/memory.ts
+var memory_exports2 = {};
+__export(memory_exports2, {
+  render: () => render6
+});
+function _pyTruthy13(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  if (typeof value === "number") {
+    return value !== 0 && !Number.isNaN(value);
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length > 0;
+  }
+  return true;
+}
+function _fmt2(x) {
+  if (!Number.isFinite(x)) {
+    if (Number.isNaN(x)) {
+      return "nan";
+    }
+    return x > 0 ? "inf" : "-inf";
+  }
+  const nd = 2;
+  const neg = x < 0 || Object.is(x, -0);
+  const ax = Math.abs(x);
+  const buf = new DataView(new ArrayBuffer(8));
+  buf.setFloat64(0, ax);
+  const bits = buf.getBigUint64(0);
+  const expo = Number(bits >> 52n & 0x7ffn);
+  const mant = bits & 0xfffffffffffffn;
+  let num;
+  let den;
+  if (expo === 0) {
+    num = mant;
+    den = 1n << 1074n;
+  } else {
+    num = mant | 0x10000000000000n;
+    const e = BigInt(expo) - 1075n;
+    if (e >= 0n) {
+      num <<= e;
+      den = 1n;
+    } else {
+      den = 1n << -e;
+    }
+  }
+  const scale = 10n ** BigInt(nd);
+  const numS = num * scale;
+  let q = numS / den;
+  const r = numS % den;
+  const twice = r * 2n;
+  if (twice > den) {
+    q += 1n;
+  } else if (twice === den && q % 2n === 1n) {
+    q += 1n;
+  }
+  const s = q.toString().padStart(nd + 1, "0");
+  const ip = s.slice(0, s.length - nd) || "0";
+  const fp = s.slice(s.length - nd);
+  const out = `${ip}.${fp}`;
+  return neg ? `-${out}` : out;
+}
+function render6(trace) {
+  const out = ["## Memory hits influencing this run", ""];
+  const entries = _pyTruthy13(trace.memory) ? trace.memory : [];
+  if (entries.length === 0) {
+    out.push("- (none)");
+    out.push("");
+    return out.join("\n");
+  }
+  for (const entryRaw of entries) {
+    const entry = entryRaw;
+    const entry_id = _pyTruthy13(entry.entry_id) ? entry.entry_id : "(unknown)";
+    const score = entry.hit_score;
+    const used_in = _pyTruthy13(entry.used_in) ? entry.used_in : "unspecified";
+    let score_str;
+    if (score instanceof PyFloat) {
+      score_str = `score ${_fmt2(score.value)}`;
+    } else if (typeof score === "boolean") {
+      score_str = `score ${_fmt2(score ? 1 : 0)}`;
+    } else if (typeof score === "number") {
+      score_str = `score ${_fmt2(score)}`;
+    } else {
+      score_str = "score n/a";
+    }
+    out.push(`- ${entry_id} (${score_str}) \u2014 used in ${used_in}`);
+  }
+  out.push("");
+  return out.join("\n");
+}
+
+// src/scripts/_cli/explain_last/sections/pack.ts
+var pack_exports = {};
+__export(pack_exports, {
+  render: () => render7
+});
+function _pyTruthy14(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  if (typeof value === "number") {
+    return value !== 0 && !Number.isNaN(value);
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length > 0;
+  }
+  return true;
+}
+function render7(trace) {
+  const pack = trace.pack;
+  if (!_pyTruthy14(pack)) {
+    return "";
+  }
+  const p = pack;
+  const pack_id = _pyTruthy14(p.id) ? p.id : "(unknown)";
+  const reason = _pyTruthy14(p.reason) ? p.reason : "";
+  const out = ["## Active pack", ""];
+  out.push(_pyTruthy14(reason) ? `- ${pack_id} \u2014 ${reason}` : `- ${pack_id}`);
+  out.push("");
+  return out.join("\n");
+}
+
+// src/scripts/_cli/explain_last/sections/provider.ts
+var provider_exports2 = {};
+__export(provider_exports2, {
+  render: () => render8
+});
+function _pyTruthy15(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  if (typeof value === "number") {
+    return value !== 0 && !Number.isNaN(value);
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length > 0;
+  }
+  return true;
+}
+function render8(trace) {
+  const provider = trace.provider;
+  if (!_pyTruthy15(provider)) {
+    return "";
+  }
+  const p = provider;
+  const pid = _pyTruthy15(p.id) ? p.id : "(unknown)";
+  const reason = _pyTruthy15(p.selection_reason) ? p.selection_reason : "(no reason recorded)";
+  const out = [
+    "## Why this provider?",
+    "",
+    `- **Provider:** \`${pid}\``,
+    `- **Selection reason:** ${reason}`,
+    ""
+  ];
+  return out.join("\n");
+}
+
+// src/scripts/_cli/explain_last/sections/route.ts
+var route_exports2 = {};
+__export(route_exports2, {
+  render: () => render9
+});
+function _pyTruthy16(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  if (typeof value === "number") {
+    return value !== 0 && !Number.isNaN(value);
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length > 0;
+  }
+  return true;
+}
+function render9(trace) {
+  const out = ["## Why this route?", ""];
+  const route = trace.route;
+  if (!_pyTruthy16(route)) {
+    out.push("- (none) \u2014 router.json missing or unreadable");
+    out.push("");
+    return out.join("\n");
+  }
+  const r = route;
+  const matched = _pyTruthy16(r.matched_rules) ? r.matched_rules : [];
+  const kernel = _pyTruthy16(r.kernel_rules) ? r.kernel_rules : [];
+  const persona = _pyTruthy16(r.persona) ? r.persona : "(none)";
+  const matched_str = matched.length > 0 ? matched.join(", ") : "(none)";
+  out.push(`- Active rules: ${matched_str}`);
+  out.push(`- Kernel rules: ${kernel.length}`);
+  out.push(`- Persona: ${persona}`);
+  out.push("");
+  return out.join("\n");
+}
+
+// src/scripts/_cli/explain_last/render.ts
+var _SECTION_ORDER = [
+  header_exports.render,
+  route_exports2.render,
+  inputs_exports2.render,
+  memory_exports2.render,
+  council_exports2.render,
+  halt_exports2.render,
+  provider_exports2.render,
+  assumptions_exports2.render,
+  pack_exports.render
+];
+var TIP_FOOTER = "_tip: pass `--json` to emit machine-readable trace; `--quiet` to drop this footer._\n";
+function _rstrip(s) {
+  return s.replace(/\s+$/u, "");
+}
+function render10(trace, options = {}) {
+  const with_footer = options.with_footer ?? true;
+  const parts = [];
+  for (const section of _SECTION_ORDER) {
+    const chunk = section(trace);
+    if (chunk) {
+      parts.push(chunk);
+    }
+  }
+  let body = `${_rstrip(parts.join("\n"))}
+`;
+  if (with_footer) {
+    body += `
+${TIP_FOOTER}`;
+  }
+  return body;
+}
+
+// src/scripts/_cli/cmd_explain.ts
+var ROUTER_FILENAME2 = "router.json";
+var ROUTER_RELATIVE2 = path7.join("dist", ROUTER_FILENAME2);
+var _HERE = fileURLToPath(import.meta.url);
+var ArgparseExit = class extends Error {
+  constructor(code) {
+    super(`argparse-exit-${code}`);
+    this.code = code;
+  }
+  code;
+};
+var SystemExitError = class extends Error {
+  constructor(code) {
+    super(`system-exit-${code}`);
+    this.code = code;
+  }
+  code;
+};
+function print(line = "") {
+  process2.stdout.write(line + "\n");
+}
+function eprint(line = "") {
+  process2.stderr.write(line + "\n");
+}
+function _jsonStrAscii(s) {
+  let out = '"';
+  for (const ch of s) {
+    const code = ch.codePointAt(0);
+    switch (ch) {
+      case '"':
+        out += '\\"';
+        break;
+      case "\\":
+        out += "\\\\";
+        break;
+      case "\n":
+        out += "\\n";
+        break;
+      case "\r":
+        out += "\\r";
+        break;
+      case "	":
+        out += "\\t";
+        break;
+      case "\b":
+        out += "\\b";
+        break;
+      case "\f":
+        out += "\\f";
+        break;
+      default:
+        if (code < 32) {
+          out += "\\u" + code.toString(16).padStart(4, "0");
+        } else if (code < 127) {
+          out += ch;
+        } else if (code <= 65535) {
+          out += "\\u" + code.toString(16).padStart(4, "0");
+        } else {
+          const v = code - 65536;
+          const hi = 55296 + (v >> 10);
+          const lo = 56320 + (v & 1023);
+          out += "\\u" + hi.toString(16).padStart(4, "0") + "\\u" + lo.toString(16).padStart(4, "0");
+        }
+    }
+  }
+  return out + '"';
+}
+function _jsonScalarAscii(value) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      if (Number.isNaN(value)) return "NaN";
+      return value > 0 ? "Infinity" : "-Infinity";
+    }
+    return String(value);
+  }
+  if (typeof value === "string") return _jsonStrAscii(value);
+  return null;
+}
+function _dumpSortedAscii(value, indent, depth) {
+  const scalar = _jsonScalarAscii(value);
+  if (scalar !== null) return scalar;
+  const pad = " ".repeat(indent * (depth + 1));
+  const closePad = " ".repeat(indent * depth);
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    const items = value.map((v) => pad + _dumpSortedAscii(v, indent, depth + 1));
+    return `[
+${items.join(",\n")}
+${closePad}]`;
+  }
+  if (typeof value === "object" && value !== null) {
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    if (keys.length === 0) return "{}";
+    const items = keys.map(
+      (k) => `${pad}${_jsonStrAscii(k)}: ${_dumpSortedAscii(obj[k], indent, depth + 1)}`
+    );
+    return `{
+${items.join(",\n")}
+${closePad}}`;
+  }
+  return _jsonStrAscii(String(value));
+}
+function _jsonDumpsIndentSortedAscii(value) {
+  return _dumpSortedAscii(value, 2, 0);
+}
+function _dumpJson(payload) {
+  process2.stdout.write(_jsonDumpsIndentSortedAscii(payload));
+  process2.stdout.write("\n");
+}
+function _exists3(p) {
+  try {
+    fs8.statSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pyReprStr(value) {
+  if (value.includes("'") && !value.includes('"')) {
+    return `"${value}"`;
+  }
+  const escaped = value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  return `'${escaped}'`;
+}
+function _resolve_root(arg) {
+  try {
+    return resolve_project_root(arg, { cwd: process2.cwd() });
+  } catch (exc) {
+    if (exc instanceof ProjectRootError) {
+      eprint(`\u274C  explain: ${exc.message}`);
+      throw new SystemExitError(2);
+    }
+    throw exc;
+  }
+}
+function _load_user_settings(project_root) {
+  const p = path7.join(project_root, DEFAULT_PROJECT_FILE);
+  if (!_exists3(p)) {
+    return {};
+  }
+  return load_agent_settings({ project_path: p }) || {};
+}
+function _load_router2(project_root) {
+  const p = path7.join(project_root, ROUTER_RELATIVE2);
+  if (!_exists3(p)) {
+    return {};
+  }
+  try {
+    return JSON.parse(fs8.readFileSync(p, { encoding: "utf-8" }));
+  } catch (exc) {
+    eprint(`\u274C  explain: cannot read ${p}: ${osErrorStr(exc)}`);
+    throw new SystemExitError(2);
+  }
+}
+function osErrorStr(exc) {
+  if (exc instanceof Error) {
+    return exc.message;
+  }
+  return String(exc);
+}
+function _explain_config(project_root, as_json) {
+  const settings = _load_user_settings(project_root);
+  const resolved_profile = resolve_profile({
+    project_root,
+    user_settings: settings
+  });
+  const resolved_preset = resolve_preset({
+    project_root,
+    user_settings: settings,
+    profile_preset_id: resolved_profile.preset_id
+  });
+  const payload = {
+    project_root: String(project_root),
+    profile: {
+      id: resolved_profile.id,
+      source: resolved_profile.source,
+      preset_id: resolved_profile.preset_id,
+      warning: resolved_profile.warning
+    },
+    preset: {
+      id: resolved_preset.id,
+      source: resolved_preset.source,
+      overrides: [...resolved_preset.overrides],
+      knobs: resolved_preset.knobs
+    },
+    env: {
+      [PROFILE_ID_ENV]: process2.env[PROFILE_ID_ENV] ?? null,
+      [PRESET_ID_ENV]: process2.env[PRESET_ID_ENV] ?? null
+    }
+  };
+  if (as_json) {
+    _dumpJson(payload);
+    return 0;
+  }
+  print(`  \u{1F4CD}  project_root: ${project_root}`);
+  print();
+  print(`  profile.id:   ${resolved_profile.id}  (source: ${resolved_profile.source})`);
+  if (resolved_profile.warning) {
+    print(`  \u26A0\uFE0F   ${resolved_profile.warning}`);
+  }
+  print(`  preset.id:    ${resolved_preset.id}  (source: ${resolved_preset.source})`);
+  if (resolved_preset.overrides.length > 0) {
+    print(`  overrides:    ${resolved_preset.overrides.join(", ")}`);
+  }
+  const knobs = resolved_preset.knobs;
+  const cost = isPlainObject(knobs["cost"]) ? knobs["cost"] : {};
+  if (Object.keys(cost).length > 0) {
+    print(
+      `  cost caps:    daily $${fmt(cost["daily_max_usd"])} \xB7 weekly $${fmt(cost["weekly_max_usd"])} \xB7 monthly $${fmt(cost["monthly_max_usd"])}`
+    );
+  }
+  const autonomy = isPlainObject(knobs["autonomy"]) ? knobs["autonomy"] : {};
+  if (Object.keys(autonomy).length > 0) {
+    print(`  autonomy:     default=${fmt(autonomy["default"])}`);
+  }
+  return 0;
+}
+function fmt(value) {
+  if (value === null || value === void 0) return "None";
+  if (typeof value === "boolean") return value ? "True" : "False";
+  return String(value);
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function _find_rule(router, name) {
+  const kernel = router["kernel"] || [];
+  if (kernel.includes(name)) {
+    return ["kernel", { id: name, triggers: [{ always: true }] }];
+  }
+  for (const tier of ["tier_1", "tier_2"]) {
+    const entries = router[tier] || [];
+    for (const entry of entries) {
+      if (entry["id"] === name) {
+        return [tier, entry];
+      }
+    }
+  }
+  return null;
+}
+function _explain_rule(project_root, name, as_json) {
+  const router = _load_router2(project_root);
+  const found = _find_rule(router, name);
+  if (found === null) {
+    eprint(`\u274C  explain: rule ${pyReprStr(name)} not found in router`);
+    return 1;
+  }
+  const [tier, entry] = found;
+  const payload = { rule: name, tier, entry };
+  if (as_json) {
+    _dumpJson(payload);
+    return 0;
+  }
+  print(`  rule:    ${name}`);
+  print(`  tier:    ${tier}`);
+  const triggers = entry["triggers"] || [];
+  print(`  triggers (${triggers.length}):`);
+  for (const trig of triggers) {
+    print(`    \xB7 ${pyStr(trig)}`);
+  }
+  const routes = entry["routes_to"] || [];
+  if (routes.length > 0) {
+    print(`  routes_to: ${routes.join(", ")}`);
+  }
+  return 0;
+}
+function pyStr(value) {
+  if (value === null || value === void 0) return "None";
+  if (typeof value === "boolean") return value ? "True" : "False";
+  if (typeof value === "string") return value;
+  if (typeof value === "number") return String(value);
+  if (Array.isArray(value)) {
+    return "[" + value.map((v) => pyReprAny(v)).join(", ") + "]";
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const parts = Object.keys(obj).map((k) => `${pyReprAny(k)}: ${pyReprAny(obj[k])}`);
+    return "{" + parts.join(", ") + "}";
+  }
+  return String(value);
+}
+function pyReprAny(value) {
+  if (value === null || value === void 0) return "None";
+  if (typeof value === "boolean") return value ? "True" : "False";
+  if (typeof value === "string") return pyReprStr(value);
+  if (typeof value === "number") return String(value);
+  if (Array.isArray(value)) {
+    return "[" + value.map((v) => pyReprAny(v)).join(", ") + "]";
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const parts = Object.keys(obj).map((k) => `${pyReprAny(k)}: ${pyReprAny(obj[k])}`);
+    return "{" + parts.join(", ") + "}";
+  }
+  return String(value);
+}
+function _matches_trigger(trigger, text, lowered) {
+  if ("keyword" in trigger) {
+    const kw = String(trigger["keyword"]).toLowerCase();
+    if (kw && lowered.includes(kw)) {
+      return `keyword: ${kw}`;
+    }
+  }
+  if ("phrase" in trigger) {
+    const ph = String(trigger["phrase"]).toLowerCase();
+    if (ph && lowered.includes(ph)) {
+      return `phrase: ${ph}`;
+    }
+  }
+  if ("path_prefix" in trigger) {
+    const prefix = String(trigger["path_prefix"]);
+    if (prefix && text.includes(prefix)) {
+      return `path_prefix: ${prefix}`;
+    }
+  }
+  return null;
+}
+function _explain_route(project_root, text, as_json) {
+  const router = _load_router2(project_root);
+  const lowered = text.toLowerCase();
+  const matches = [];
+  const tier_1 = router["tier_1"] || [];
+  for (const entry of tier_1) {
+    const triggers = entry["triggers"] || [];
+    for (const trig of triggers) {
+      const reason = _matches_trigger(trig, text, lowered);
+      if (reason !== null) {
+        matches.push({ id: entry["id"], tier: "tier_1", reason });
+        break;
+      }
+    }
+  }
+  const kernel_always = [...router["kernel"] || []];
+  const payload = {
+    input: text,
+    kernel_always,
+    tier_1_matches: matches
+  };
+  if (as_json) {
+    _dumpJson(payload);
+    return 0;
+  }
+  print(`  input: ${pyReprStr(text)}`);
+  print();
+  print(`  kernel (always active, ${kernel_always.length}):`);
+  for (const kid of kernel_always) {
+    print(`    \xB7 ${pyStr(kid)}`);
+  }
+  print();
+  print(`  tier-1 matches (${matches.length}):`);
+  if (matches.length === 0) {
+    print("    \xB7 (no trigger matched \u2014 only kernel rules active)");
+    return 1;
+  }
+  for (const match of matches) {
+    print(`    \xB7 ${match["id"]}  (${match["reason"]})`);
+  }
+  return 0;
+}
+function _explain_last(project_root, state_file, as_json, quiet) {
+  const settings = _load_user_settings(project_root);
+  const explain_raw = settings["explain"];
+  const explain_cfg = isPlainObject(explain_raw) ? explain_raw : {};
+  if (explain_cfg["enable_last"] === false) {
+    print("explain last disabled by settings (explain.enable_last)");
+    return 0;
+  }
+  const target_state = state_file || path7.join(project_root, ".work-state.json");
+  let trace;
+  try {
+    trace = build_trace(project_root, target_state);
+  } catch (exc) {
+    if (exc instanceof StateLoadError) {
+      let rel;
+      const relativeTo = relativeToOrNull(target_state, project_root);
+      if (relativeTo !== null) {
+        rel = relativeTo;
+      } else {
+        rel = path7.basename(target_state);
+      }
+      const msg = exc.message.split(target_state).join(rel);
+      eprint(`\u274C  explain last: ${msg}`);
+      return exc.exitCode;
+    }
+    throw exc;
+  }
+  if (as_json) {
+    _dumpJson(trace);
+    return 0;
+  }
+  process2.stdout.write(render10(trace, { with_footer: !quiet }));
+  return 0;
+}
+function relativeToOrNull(p, base) {
+  const rel = path7.relative(base, p);
+  if (rel === "") return rel;
+  if (rel.startsWith("..") || path7.isAbsolute(rel)) {
+    return null;
+  }
+  return rel;
+}
+var _LAST_HELP = `usage: agent-config explain last [--project PATH] [--state-file PATH]
+                                 [--json] [--quiet]
+
+Reconstruct the execution trace for the most recent /work,
+/implement-ticket, /council, or /video run. Read-only; never
+makes network calls. Output is the ExplainTrace v1 contract:
+  docs/contracts/explain-trace.schema.json
+
+why-slots answered (Markdown sections; JSON keys in parens):
+
+  inputs       \u2014 profile / preset / rule_loading_tier with per-knob source
+                 (pack | profile | preset | user | env | runtime |
+                  default)
+  route        \u2014 matched tier-1 rules \xB7 kernel rules \xB7 active persona
+                 (route)
+  memory       \u2014 memory-MCP entries that influenced this run, with
+                 hit-score + step-id (memory)
+  council      \u2014 council members consulted with per-member verdict
+                 (council)
+  assumptions  \u2014 assumptions recorded during refine + per-halt
+                 (assumptions)
+  pack         \u2014 discovery-manifest pack selection rationale (pack)
+  halt         \u2014 reason \xB7 step \xB7 surface for the most recent halt
+                 (halt; Phase 3)
+  provider     \u2014 /video provider selection rationale; omitted for
+                 non-video runs (provider; Phase 3)
+
+options:
+  --project PATH       project root (defaults to anchor walk from cwd)
+  --state-file PATH    .work-state.json path (default <root>/.work-state.json)
+  --json               emit ExplainTrace JSON instead of Markdown
+  --quiet              suppress the trailing tip footer
+
+exit codes:
+  0  trace rendered, or disabled by settings (explain.enable_last)
+  1  no recent run found (state file missing or unreadable)
+  2  invocation error (bad project root, bad --state-file path)
+`;
+var PROG = "agent-config explain";
+var SUBJECT_CHOICES = ["config", "rule", "route", "last"];
+var USAGE = `usage: ${PROG} [-h] [--project PROJECT] [--state-file STATE_FILE]
+                            [--json] [--quiet]
+                            {config,rule,route,last} [target]
+`;
+function _argError(msg) {
+  process2.stderr.write(USAGE);
+  process2.stderr.write(`${PROG}: error: ${msg}
+`);
+  throw new ArgparseExit(2);
+}
+function _parse(argv) {
+  const opts = {
+    subject: "",
+    target: null,
+    project: null,
+    state_file: null,
+    as_json: false,
+    quiet: false
+  };
+  const positionals = [];
+  let i = 0;
+  while (i < argv.length) {
+    const a = argv[i];
+    if (a === "-h" || a === "--help") {
+      process2.stdout.write(USAGE);
+      throw new ArgparseExit(0);
+    }
+    const eq = a.startsWith("--") ? a.indexOf("=") : -1;
+    const flag = eq >= 0 ? a.slice(0, eq) : a;
+    const inlineVal = eq >= 0 ? a.slice(eq + 1) : null;
+    if (flag === "--json") {
+      if (inlineVal !== null) {
+        _argError(`argument --json: ignored explicit argument '${inlineVal}'`);
+      }
+      opts.as_json = true;
+      i += 1;
+      continue;
+    }
+    if (flag === "--quiet") {
+      if (inlineVal !== null) {
+        _argError(`argument --quiet: ignored explicit argument '${inlineVal}'`);
+      }
+      opts.quiet = true;
+      i += 1;
+      continue;
+    }
+    if (flag === "--project" || flag === "--state-file") {
+      const dest = flag === "--project" ? "project" : "state_file";
+      let value;
+      if (inlineVal !== null) {
+        value = inlineVal;
+      } else {
+        if (i + 1 >= argv.length) {
+          _argError(`argument ${flag}: expected one argument`);
+        }
+        value = argv[i + 1];
+        i += 1;
+      }
+      opts[dest] = value;
+      i += 1;
+      continue;
+    }
+    if (a.startsWith("-") && a !== "-") {
+      _argError(`unrecognized arguments: ${a}`);
+    }
+    positionals.push(a);
+    i += 1;
+  }
+  if (positionals.length === 0) {
+    _argError("the following arguments are required: subject");
+  }
+  const subject = positionals[0];
+  if (!SUBJECT_CHOICES.includes(subject)) {
+    _argError(
+      `argument subject: invalid choice: '${subject}' (choose from ${SUBJECT_CHOICES.map((c) => `'${c}'`).join(", ")})`
+    );
+  }
+  opts.subject = subject;
+  if (positionals.length >= 2) {
+    opts.target = positionals[1];
+  }
+  if (positionals.length > 2) {
+    _argError(`unrecognized arguments: ${positionals.slice(2).join(" ")}`);
+  }
+  return opts;
+}
+function main(argv = null) {
+  const argv_list = argv !== null ? Array.from(argv) : process2.argv.slice(2);
+  if (argv_list.slice(0, 1).length === 1 && argv_list[0] === "last" && argv_list.slice(1).some((a) => a === "-h" || a === "--help")) {
+    process2.stdout.write(_LAST_HELP);
+    return 0;
+  }
+  const opts = _parse(argv_list);
+  let project_root;
+  try {
+    [project_root] = _resolve_root(opts.project);
+  } catch (exc) {
+    if (exc instanceof SystemExitError) {
+      return exc.code;
+    }
+    throw exc;
+  }
+  if (opts.subject === "config") {
+    return _explain_config(project_root, opts.as_json);
+  }
+  if (opts.subject === "last") {
+    const state_path = opts.state_file ? opts.state_file : null;
+    return _explain_last(project_root, state_path, opts.as_json, opts.quiet);
+  }
+  if (opts.target === null) {
+    eprint(`\u274C  explain: '${opts.subject}' requires a target argument`);
+    return 2;
+  }
+  if (opts.subject === "rule") {
+    return _explain_rule(project_root, opts.target, opts.as_json);
+  }
+  return _explain_route(project_root, opts.target, opts.as_json);
+}
+function _isCliEntry() {
+  if (process2.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL(path7.resolve(process2.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs8.realpathSync(fileURLToPath(import.meta.url));
+    const argv = fs8.realpathSync(path7.resolve(process2.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry() || process2.argv[1] === _HERE) {
+  try {
+    process2.exitCode = main(process2.argv.slice(2));
+  } catch (e) {
+    if (e instanceof ArgparseExit) {
+      process2.exitCode = e.code;
+    } else if (e instanceof SystemExitError) {
+      process2.exitCode = e.code;
+    } else {
+      throw e;
+    }
+  }
+}
+export {
+  ArgparseExit,
+  SystemExitError,
+  _LAST_HELP,
+  _explain_config,
+  _explain_last,
+  _explain_route,
+  _explain_rule,
+  _find_rule,
+  _load_router2 as _load_router,
+  _load_user_settings,
+  _matches_trigger,
+  _parse,
+  _resolve_root,
+  main
+};