@event4u/agent-config 16.2.0 → 16.4.0

package/dist/cli-delegate/{chunk-RGNIWTEA.js → chunk-XQTPXKFA.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-F7DQWYR5.js";
 import {
   load_agent_settings
-} from "./chunk-FC75PGJE.js";
+} from "./chunk-H76PHZBI.js";
 
 // src/scripts/chat_history.ts
 import { createHash } from "node:crypto";

package/dist/cli-delegate/{chunk-NUHLI2RX.js → chunk-YCU3TIXH.js}

@@ -28,6 +28,7 @@ function _deriveRoots(root) {
   };
 }
 var _roots = _deriveRoots(_DEFAULT_ROOT);
+var SRC_SKILLS = () => _roots.SRC_SKILLS;
 function _isDir(p) {
   try {
     return fs.statSync(p).isDirectory();
@@ -76,5 +77,6 @@ function artefact_roots() {
 }
 
 export {
+  SRC_SKILLS,
   artefact_roots
 };

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

@@ -0,0 +1,210 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/scripts/_lib/lexical_index.ts
+var BM25_K1 = 1.5;
+var BM25_B = 0.75;
+var MIN_TOKEN_LEN = 2;
+function tokenize(s) {
+  const out = [];
+  for (const raw of s.toLowerCase().split(/[^a-z0-9]+/)) {
+    if (raw.length >= MIN_TOKEN_LEN) out.push(raw);
+  }
+  return out;
+}
+function trigrams(s) {
+  const norm = s.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+  const out = /* @__PURE__ */ new Set();
+  if (norm.length < 3) {
+    if (norm.length > 0) out.add(norm);
+    return out;
+  }
+  for (let i = 0; i + 3 <= norm.length; i++) {
+    out.add(norm.slice(i, i + 3));
+  }
+  return out;
+}
+var LexicalIndex = class {
+  docs = /* @__PURE__ */ new Map();
+  df = /* @__PURE__ */ new Map();
+  n;
+  avgdl;
+  constructor(documents) {
+    let totalLen = 0;
+    for (const d of documents) {
+      const tokens = tokenize(d.text);
+      const tf = /* @__PURE__ */ new Map();
+      for (const t of tokens) tf.set(t, (tf.get(t) ?? 0) + 1);
+      for (const t of tf.keys()) this.df.set(t, (this.df.get(t) ?? 0) + 1);
+      this.docs.set(d.id, { id: d.id, len: tokens.length, tf, trigrams: trigrams(d.text) });
+      totalLen += tokens.length;
+    }
+    this.n = documents.length;
+    this.avgdl = this.n > 0 ? totalLen / this.n : 0;
+  }
+  /** Robertson–Spärck-Jones IDF, floored at 0 so common terms never subtract. */
+  idf(term) {
+    const df = this.df.get(term) ?? 0;
+    if (df === 0) return 0;
+    return Math.max(0, Math.log(1 + (this.n - df + 0.5) / (df + 0.5)));
+  }
+  /**
+   * BM25 score of one document against the tokenised query terms, weighted by
+   * **term coverage**: the raw BM25 sum is multiplied by `coverage²`, where
+   * `coverage = distinct-query-terms-matched / distinct-query-terms`. This
+   * stops a single generic, high-TF term match from outranking a document that
+   * matches several rarer query terms once each (Phase 1 refinement). A
+   * single-term query has `coverage == 1`, so its score is unchanged — the
+   * weighting only re-orders genuinely multi-term queries.
+   */
+  score(queryTerms, docId) {
+    const doc = this.docs.get(docId);
+    if (doc === void 0 || doc.len === 0) return 0;
+    let s = 0;
+    const matched = /* @__PURE__ */ new Set();
+    for (const term of queryTerms) {
+      const tf = doc.tf.get(term);
+      if (tf === void 0) continue;
+      const idf = this.idf(term);
+      if (idf === 0) continue;
+      const denom = tf + BM25_K1 * (1 - BM25_B + BM25_B * doc.len / (this.avgdl || 1));
+      s += idf * (tf * (BM25_K1 + 1)) / denom;
+      matched.add(term);
+    }
+    if (s === 0) return 0;
+    const distinctQuery = new Set(queryTerms).size;
+    const coverage = distinctQuery > 0 ? matched.size / distinctQuery : 1;
+    return s * coverage * coverage;
+  }
+  /**
+   * Rank documents for a set of query keys (phrases are tokenised). A
+   * character-trigram prefilter selects candidates cheaply; the guard keeps
+   * any doc sharing a query TOKEN even when no trigram overlaps, so the
+   * prefilter never drops a genuine lexical match. Ties break by id for a
+   * stable, deterministic order.
+   */
+  rank(queryKeys) {
+    const queryText = queryKeys.join(" ");
+    const qTerms = tokenize(queryText);
+    const qTermSet = new Set(qTerms);
+    const qTrigrams = trigrams(queryText);
+    const candidates = [];
+    for (const [id, doc] of this.docs) {
+      let hit = false;
+      for (const t of qTrigrams) {
+        if (doc.trigrams.has(t)) {
+          hit = true;
+          break;
+        }
+      }
+      if (!hit) {
+        for (const t of qTermSet) {
+          if (doc.tf.has(t)) {
+            hit = true;
+            break;
+          }
+        }
+      }
+      if (hit) candidates.push(id);
+    }
+    const scored = candidates.map((id) => ({ id, score: this.score(qTerms, id) })).filter((r) => r.score > 0);
+    scored.sort((a, b) => b.score - a.score || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    return scored;
+  }
+  /** Document count — for the caller's tripwire / diagnostics. */
+  get size() {
+    return this.n;
+  }
+};
+
+// src/scripts/_lib/sqlite_guard.ts
+import { createRequire } from "node:module";
+var SqliteUnavailableError = class extends Error {
+  constructor(callerName, cause) {
+    super(
+      `node:sqlite is unavailable in this runtime (${cause}). ${callerName} requires Node with the built-in SQLite module.`
+    );
+    this.name = "SqliteUnavailableError";
+  }
+};
+var _sqliteWarningSilenced = false;
+function _silenceSqliteExperimentalWarning() {
+  if (_sqliteWarningSilenced) return;
+  _sqliteWarningSilenced = true;
+  const orig = process.emitWarning.bind(process);
+  process.emitWarning = ((warning, ...rest) => {
+    const text = typeof warning === "string" ? warning : warning?.message ?? "";
+    if (/SQLite is an experimental/i.test(text)) return;
+    orig(warning, ...rest);
+  });
+}
+var _require;
+function _syncRequire() {
+  if (_require === void 0) {
+    _require = createRequire(import.meta.url);
+  }
+  return _require;
+}
+function loadSqliteSync(callerName) {
+  _silenceSqliteExperimentalWarning();
+  try {
+    return _syncRequire()("node:sqlite");
+  } catch (exc) {
+    const message = exc instanceof Error ? exc.message : String(exc);
+    throw new SqliteUnavailableError(callerName, message);
+  }
+}
+function isSqliteAvailableSync() {
+  _silenceSqliteExperimentalWarning();
+  try {
+    _syncRequire()("node:sqlite");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function probeFts5Sync() {
+  let sqlite;
+  try {
+    sqlite = loadSqliteSync("sqlite_guard.probeFts5Sync");
+  } catch {
+    return false;
+  }
+  let conn = null;
+  try {
+    conn = new sqlite.DatabaseSync(":memory:");
+    conn.exec("CREATE VIRTUAL TABLE _fts5_probe USING fts5(body)");
+    conn.exec("INSERT INTO _fts5_probe(body) VALUES ('probe')");
+    const row = conn.prepare("SELECT body FROM _fts5_probe WHERE _fts5_probe MATCH 'probe'").get();
+    return row !== void 0;
+  } catch {
+    return false;
+  } finally {
+    try {
+      conn?.close();
+    } catch {
+    }
+  }
+}
+function readUserVersion(conn) {
+  const row = conn.prepare("PRAGMA user_version").get();
+  const v = row?.["user_version"];
+  if (typeof v === "bigint") return Number(v);
+  if (typeof v === "number") return v;
+  return 0;
+}
+function stampUserVersion(conn, version) {
+  if (!Number.isInteger(version) || version < 0 || version > 2 ** 31 - 1) {
+    throw new RangeError(`stampUserVersion: version out of range: ${version}`);
+  }
+  conn.exec(`PRAGMA user_version = ${version}`);
+}
+
+export {
+  tokenize,
+  LexicalIndex,
+  loadSqliteSync,
+  isSqliteAvailableSync,
+  probeFts5Sync,
+  readUserVersion,
+  stampUserVersion
+};

package/dist/cli-delegate/{chunk-WGXTVKCQ.js → chunk-ZUZKZYCN.js}

@@ -1,13 +1,15 @@
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
 import {
   buildInstallPlan,
-  classifyOwnership,
-  recordedHashesForRoot,
   sha256File
-} from "./chunk-YDPILCOL.js";
+} from "./chunk-523HCFYO.js";
 import {
   detectToolPresence
 } from "./chunk-A4QJ6ENT.js";
+import {
+  classifyOwnership,
+  recordedHashesForRoot
+} from "./chunk-OKJUIAPS.js";
 
 // src/install/preflight.ts
 import { accessSync, constants, existsSync as existsSync2, statSync } from "node:fs";

package/dist/cli-delegate/cmd_analyze_session.js

@@ -1,5 +1,11 @@
 #!/usr/bin/env tsx
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  atomic_write_json
+} from "./chunk-7HKRE54K.js";
+import {
+  readHookStdin
+} from "./chunk-F7DQWYR5.js";
 import {
   StateLoadError,
   load_state
@@ -7,22 +13,200 @@ import {
 import {
   ProjectRootError,
   resolve_project_root
-} from "./chunk-FC75PGJE.js";
-import "./chunk-NDJLNC6Q.js";
+} from "./chunk-H76PHZBI.js";
+import "./chunk-T6BP34WI.js";
+import "./chunk-MCJYCQPF.js";
 import "./chunk-J55WI3RR.js";
 
 // src/scripts/_cli/cmd_analyze_session.ts
-import * as fs from "node:fs";
-import * as path from "node:path";
-import process from "node:process";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+import process2 from "node:process";
+import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "node:url";
+
+// src/scripts/context_hygiene_hook.ts
+import fs from "node:fs";
+import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-var _HERE = fileURLToPath(import.meta.url);
-var CONTEXT_HYGIENE_RELATIVE = path.join(
-  "agents",
-  "runtime",
-  "state",
-  "context-hygiene.json"
-);
+var STATE_DIR = path.join("agents", "state");
+var STATE_FILE = path.join(STATE_DIR, "context-hygiene.json");
+var HISTORY_DEPTH = 5;
+var FRESHNESS_MILESTONES = [20, 40, 60];
+function _empty_state() {
+  return {
+    tool_calls: 0,
+    tool_history: [],
+    freshness_threshold: null
+  };
+}
+function _load_state(target) {
+  let isFile = false;
+  try {
+    isFile = fs.statSync(target).isFile();
+  } catch {
+    isFile = false;
+  }
+  if (!isFile) {
+    return _empty_state();
+  }
+  try {
+    const decoded = JSON.parse(fs.readFileSync(target, "utf-8"));
+    if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
+      return decoded;
+    }
+  } catch {
+  }
+  return _empty_state();
+}
+function _extract_tool(payload) {
+  for (const key of ["tool_name", "toolName", "tool"]) {
+    const v = payload[key];
+    if (typeof v === "string" && v) {
+      return v;
+    }
+  }
+  return null;
+}
+function _milestone_hit(prev, curr) {
+  for (const ms of FRESHNESS_MILESTONES) {
+    if (prev < ms && ms <= curr) {
+      return ms;
+    }
+  }
+  return null;
+}
+function _now_iso() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "+00:00");
+}
+function _asInt(v) {
+  if (!v) {
+    return 0;
+  }
+  if (typeof v === "number") {
+    return Math.trunc(v);
+  }
+  const n = Number(v);
+  return Number.isFinite(n) ? Math.trunc(n) : 0;
+}
+function _update(state, tool) {
+  if (tool === null) {
+    state["checked_at"] = _now_iso();
+    return state;
+  }
+  const prev_count = _asInt(state["tool_calls"]);
+  const curr_count = prev_count + 1;
+  state["tool_calls"] = curr_count;
+  let hist = state["tool_history"];
+  if (!Array.isArray(hist)) {
+    hist = [];
+  }
+  hist.push(tool);
+  state["tool_history"] = hist.slice(-HISTORY_DEPTH);
+  const ms = _milestone_hit(prev_count, curr_count);
+  if (ms !== null) {
+    state["freshness_threshold"] = ms;
+  }
+  state["checked_at"] = _now_iso();
+  return state;
+}
+function _write_state(consumer_root, state) {
+  atomic_write_json(path.join(consumer_root, STATE_FILE), state);
+}
+function run(stdin_text, options) {
+  const { consumer_root } = options;
+  const verbose = options.verbose ?? false;
+  let payload = {};
+  if (stdin_text.trim()) {
+    try {
+      const decoded = JSON.parse(stdin_text);
+      if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
+        payload = decoded;
+      }
+    } catch {
+    }
+  }
+  if (["schema_version", "platform", "event", "payload"].every((k) => k in payload)) {
+    const inner = payload["payload"];
+    payload = typeof inner === "object" && inner !== null && !Array.isArray(inner) ? inner : {};
+  }
+  const target = path.join(consumer_root, STATE_FILE);
+  let state = _load_state(target);
+  state = _update(state, _extract_tool(payload));
+  try {
+    _write_state(consumer_root, state);
+  } catch {
+    if (verbose) {
+      process.stderr.write("context-hygiene-hook: state write failed\n");
+    }
+    return 0;
+  }
+  if (verbose) {
+    process.stderr.write(
+      `context-hygiene-hook: tool_calls=${pyRepr(state["tool_calls"])} threshold=${pyRepr(state["freshness_threshold"])}
+`
+    );
+  }
+  return 0;
+}
+function pyRepr(value) {
+  if (value === null || value === void 0) {
+    return "None";
+  }
+  if (typeof value === "boolean") {
+    return value ? "True" : "False";
+  }
+  return String(value);
+}
+function parse_args(argv) {
+  let platform = "generic";
+  let verbose = false;
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--platform") {
+      platform = argv[i + 1] ?? "generic";
+      i += 1;
+    } else if (arg !== void 0 && arg.startsWith("--platform=")) {
+      platform = arg.slice("--platform=".length);
+    } else if (arg === "--verbose") {
+      verbose = true;
+    }
+  }
+  return { platform, verbose };
+}
+function _readStdin() {
+  return readHookStdin();
+}
+function main(argv) {
+  const args = parse_args(argv ?? process.argv.slice(2));
+  return run(_readStdin(), { consumer_root: process.cwd(), verbose: args.verbose });
+}
+function _isCliEntry() {
+  if (true) {
+    return false;
+  }
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs.realpathSync(fileURLToPath(import.meta.url));
+    const argv = fs.realpathSync(path.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+var isCliEntry = _isCliEntry();
+if (isCliEntry) {
+  process.exit(main(process.argv.slice(2)));
+}
+
+// src/scripts/_cli/cmd_analyze_session.ts
+var _HERE = fileURLToPath2(import.meta.url);
+var CONTEXT_HYGIENE_RELATIVE = STATE_FILE;
 var SystemExitError = class extends Error {
   constructor(code) {
     super(`system-exit-${code}`);
@@ -38,14 +222,14 @@ var ArgparseExit = class extends Error {
   code;
 };
 function eprint(line = "") {
-  process.stderr.write(line + "\n");
+  process2.stderr.write(line + "\n");
 }
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function _resolve_root(arg) {
   try {
-    const [root] = resolve_project_root(arg, { cwd: process.cwd() });
+    const [root] = resolve_project_root(arg, { cwd: process2.cwd() });
     return root;
   } catch (exc) {
     if (exc instanceof ProjectRootError) {
@@ -56,21 +240,21 @@ function _resolve_root(arg) {
   }
 }
 function relativeToOrNull(p, base) {
-  const rel = path.relative(base, p);
+  const rel = path2.relative(base, p);
   if (rel === "") return rel;
-  if (rel.startsWith("..") || path.isAbsolute(rel)) {
+  if (rel.startsWith("..") || path2.isAbsolute(rel)) {
     return null;
   }
   return rel;
 }
 function _load_context_hygiene(project_root) {
-  const p = path.join(project_root, CONTEXT_HYGIENE_RELATIVE);
-  if (!fs.existsSync(p)) {
+  const p = path2.join(project_root, CONTEXT_HYGIENE_RELATIVE);
+  if (!fs2.existsSync(p)) {
     return null;
   }
   let text;
   try {
-    text = fs.readFileSync(p, "utf-8");
+    text = fs2.readFileSync(p, "utf-8");
   } catch {
     return null;
   }
@@ -140,11 +324,7 @@ function render_report(state, hygiene) {
     lines.push("_Context-hygiene snapshot not available._");
   } else {
     const toolCalls = intOrUnknown(hygiene["tool_calls"]);
-    const consecutive = intOrUnknown(hygiene["consecutive_same_tool"]);
-    const loop = hygiene["loop_detected"] === true;
     lines.push(`- Tool calls: ${toolCalls}`);
-    lines.push(`- Consecutive same-tool calls: ${consecutive}`);
-    lines.push(`- Loop detected: ${loop ? "yes" : "no"}`);
   }
   lines.push("");
   lines.push("## Token / cost");
@@ -154,14 +334,14 @@ function render_report(state, hygiene) {
   return lines.join("\n");
 }
 function _analyze_session(project_root, state_file) {
-  const target_state = state_file || path.join(project_root, ".work-state.json");
+  const target_state = state_file || path2.join(project_root, ".work-state.json");
   let state;
   try {
     state = load_state(target_state);
   } catch (exc) {
     if (exc instanceof StateLoadError) {
       const rel = relativeToOrNull(target_state, project_root);
-      const shown = rel !== null ? rel : path.basename(target_state);
+      const shown = rel !== null ? rel : path2.basename(target_state);
       const msg = exc.message.split(target_state).join(shown);
       eprint(`\u274C  analyze-session: ${msg}`);
       return exc.exitCode;
@@ -169,7 +349,7 @@ function _analyze_session(project_root, state_file) {
     throw exc;
   }
   const hygiene = _load_context_hygiene(project_root);
-  process.stdout.write(render_report(state, hygiene));
+  process2.stdout.write(render_report(state, hygiene));
   return 0;
 }
 var PROG = "agent-config analyze-session";
@@ -185,8 +365,8 @@ Sources read:
     \xB7 changes  \u2014 files touched
     \xB7 outcomes \u2014 per-directive success / blocked
     \xB7 halts    \u2014 recorded halts
-  agents/runtime/state/context-hygiene.json
-    \xB7 tool_calls \xB7 consecutive_same_tool \xB7 loop_detected
+  agents/state/context-hygiene.json
+    \xB7 tool_calls
 
 Token/cost is NOT reported \u2014 this package has no per-session token
 source (only video-specific telemetry).
@@ -202,8 +382,8 @@ exit codes:
   2  invocation error (bad project root, bad --state-file path)
 `;
 function _argError(msg) {
-  process.stderr.write(USAGE);
-  process.stderr.write(`${PROG}: error: ${msg}
+  process2.stderr.write(USAGE);
+  process2.stderr.write(`${PROG}: error: ${msg}
 `);
   throw new ArgparseExit(2);
 }
@@ -213,7 +393,7 @@ function _parse(argv) {
   while (i < argv.length) {
     const a = argv[i];
     if (a === "-h" || a === "--help") {
-      process.stdout.write(_HELP);
+      process2.stdout.write(_HELP);
       throw new ArgparseExit(0);
     }
     const eq = a.startsWith("--") ? a.indexOf("=") : -1;
@@ -239,8 +419,8 @@ function _parse(argv) {
   }
   return opts;
 }
-function main(argv = null) {
-  const argv_list = argv !== null ? Array.from(argv) : process.argv.slice(2);
+function main2(argv = null) {
+  const argv_list = argv !== null ? Array.from(argv) : process2.argv.slice(2);
   const opts = _parse(argv_list);
   let project_root;
   try {
@@ -253,30 +433,30 @@ function main(argv = null) {
   }
   return _analyze_session(project_root, opts.state_file);
 }
-function _isCliEntry() {
-  if (process.argv[1] === void 0) {
+function _isCliEntry2() {
+  if (process2.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL2(path2.resolve(process2.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs.realpathSync(fileURLToPath(import.meta.url));
-    const argv = fs.realpathSync(path.resolve(process.argv[1]));
+    const here = fs2.realpathSync(fileURLToPath2(import.meta.url));
+    const argv = fs2.realpathSync(path2.resolve(process2.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry() || process.argv[1] === _HERE) {
+if (_isCliEntry2() || process2.argv[1] === _HERE) {
   try {
-    process.exitCode = main(process.argv.slice(2));
+    process2.exitCode = main2(process2.argv.slice(2));
   } catch (e) {
     if (e instanceof ArgparseExit) {
-      process.exitCode = e.code;
+      process2.exitCode = e.code;
     } else if (e instanceof SystemExitError) {
-      process.exitCode = e.code;
+      process2.exitCode = e.code;
     } else {
       throw e;
     }
@@ -289,6 +469,6 @@ export {
   _load_context_hygiene,
   _parse,
   _resolve_root,
-  main,
+  main2 as main,
   render_report
 };

package/dist/cli-delegate/cmd_brand_status.js

@@ -1,8 +1,9 @@
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
 import {
   resolve_project_root
-} from "./chunk-FC75PGJE.js";
-import "./chunk-NDJLNC6Q.js";
+} from "./chunk-H76PHZBI.js";
+import "./chunk-T6BP34WI.js";
+import "./chunk-MCJYCQPF.js";
 import "./chunk-J55WI3RR.js";
 
 // src/scripts/_cli/cmd_brand_status.ts