@event4u/agent-config 16.5.0 → 17.0.0

package/dist/shared/brandTokenDocument.js

@@ -0,0 +1,47 @@
+/**
+ * Is this text a DTCG token document? The question every reader of a brand
+ * token file has to answer before it uses one, declared once.
+ *
+ * `brand:status` answered it first and kept the answer in the CLI, so the two
+ * other readers — the UI scaffold's `token_seed` line and the asset renderer's
+ * background read — fell back to `isFile()`. A malformed `tokens.json` beside a
+ * valid `assets/tokens.json` then seeded the plan from the broken one and the
+ * renderer skipped straight to its fallback background, while `brand:status`
+ * reported the valid file as the brand. Three readers, three answers.
+ *
+ * It lives beside `brandTokenPaths.ts` for the same reason: `src/shared/` is
+ * the one home the compiled CLI, the tsx-run work-engine tree and the bundled
+ * delegates all reach at runtime. Keep it dependency-free — it takes TEXT, not
+ * a path, so nothing here touches the filesystem and every caller keeps its own
+ * read, its own error handling and its own notion of a root.
+ */
+/** Depth bound: a token tree this deep is pathological, not a document. */
+const MAX_DEPTH = 64;
+function hasDtcgToken(node, depth = 0) {
+    if (depth > MAX_DEPTH || typeof node !== 'object' || node === null || Array.isArray(node))
+        return false;
+    if ('$value' in node)
+        return true;
+    return Object.values(node).some((v) => hasDtcgToken(v, depth + 1));
+}
+/**
+ * Parse before present: `null` when the text is a DTCG token document, else the
+ * reason it is not one. A file that merely exists is not a brand.
+ */
+export function tokenDocumentError(text) {
+    let doc;
+    try {
+        doc = JSON.parse(text);
+    }
+    catch (exc) {
+        return `not JSON: ${exc instanceof Error ? exc.message : String(exc)}`;
+    }
+    if (typeof doc !== 'object' || doc === null || Array.isArray(doc)) {
+        return 'not a DTCG document: the root is not an object';
+    }
+    if (!hasDtcgToken(doc)) {
+        return 'not a DTCG document: no token carries a `$value`';
+    }
+    return null;
+}
+//# sourceMappingURL=brandTokenDocument.js.map

package/dist/shared/brandTokenPaths.js

@@ -0,0 +1,43 @@
+/**
+ * The paths the brand resolver searches for a project's DTCG `tokens.json`,
+ * in its order. First hit wins. ONE declaration, three readers.
+ *
+ * Why here, and not a re-export from either side: this list was declared twice — once in the UI scaffold directive
+ * (`agent-src/templates/scripts/work_engine/directives/ui/scaffold.ts`) and
+ * once in the asset renderer's types module (`cli/commands/uiRenderAssetTypes.ts`)
+ * — and the two had already drifted: the renderer built its last entry with
+ * `path.join`, so on Windows it searched `agents\settings\brand\tokens.json`
+ * while the scaffold searched the forward-slash form. Two answers to "what
+ * counts as this project's brand" is the defect; which separator wins is only
+ * how it showed.
+ *
+ * A re-export from the renderer into the scaffold was tried first and reverted
+ * (`cli/commands/uiAudit.ts` records the same class for the coverage
+ * vocabulary): it creates a RUNTIME edge from the compiled CLI into the
+ * work-engine TEMPLATE tree, which ships as `.ts` beside the bundle rather than
+ * inside it, so the published package fails to resolve it at import time.
+ *
+ * `src/shared/` is the one home both trees can reach at runtime, and the SAME
+ * relative specifier resolves in both projections:
+ *
+ *   - `src/cli/commands/*` compiles under `rootDir: src`, so `../../shared/…`
+ *     lands on `dist/shared/brandTokenPaths.js`.
+ *   - the work-engine tree runs under tsx from `src/agent-src/templates/…` and
+ *     is projected byte-identically to `dist/agent-src/templates/…`;
+ *     `../../../../../../shared/…` is `src/shared/brandTokenPaths.ts` in the
+ *     first and `dist/shared/brandTokenPaths.js` in the second.
+ *
+ * Keep this module dependency-free. It imports nothing — not even `node:path`,
+ * which is what let the two copies disagree in the first place. These are
+ * repo-relative *conventional* paths written with forward slashes; a caller
+ * joins them onto a root with `path.join`, which accepts that form on every
+ * platform.
+ */
+/** The four paths the brand resolver searches, in its order. First hit wins. */
+export const BRAND_TOKEN_PATHS = [
+    'tokens.json',
+    'assets/tokens.json',
+    'resources/tokens.json',
+    'agents/settings/brand/tokens.json',
+];
+//# sourceMappingURL=brandTokenPaths.js.map

package/dist/shared/settingsCarveOut.js

@@ -35,13 +35,6 @@ export const SETTINGS_CARVE_OUT = [
             + 'Once a file exists, an absent key means legacy-all by documented contract, '
             + 'so an existing install is never silently narrowed on upgrade.',
     },
-    {
-        key: 'projection.rule_workspaces',
-        reader: 'src/install/rule_scope.ts:96 ruleScopeFromSettings',
-        absentResolvesTo: 'null — LEGACY_ALL, i.e. every rule ships including maintainer-only ones',
-        reason: 'Same upgrade contract as projection.mode, and the failure is louder: '
-            + 'an absent list widens the projection instead of narrowing it.',
-    },
     {
         key: 'discipline_profile',
         reader: 'work_engine/_lib/agent_settings.ts:1263',

package/dist/shared/skillRanking.js

@@ -34,10 +34,32 @@
  *
  * Pure — no imports, no I/O, no clock.
  */
-// re.compile(r"[a-z][a-z0-9]+") — applied to the lowercased text.
-const TOKEN_RE = /[a-z][a-z0-9]+/g;
-/** Ported verbatim from the Python scorer. Order is irrelevant; membership is not. */
-export const STOPWORDS = new Set([
+/**
+ * The token shape. A LETTER followed by letters or digits, in any script.
+ *
+ * It was `re.compile(r"[a-z][a-z0-9]+")`, ported verbatim from the Python
+ * scorer, and that class cannot see a letter outside ASCII. Reproduced on the
+ * tree this replaced it in: `Prüfung` indexed as `fung`, `Größe` as nothing at
+ * all, `Abhängigkeiten` as the two fragments `abh` and `ngigkeiten`. A prompt
+ * written in German was therefore not ranked badly — most of its content words
+ * were not ranked at all, because the class split each one at its first umlaut
+ * and the pieces fell under the three-code-point floor below.
+ *
+ * `\p{L}` and `\p{N}` keep the ASCII behaviour byte-identical — the lowercased
+ * `a-z` and `0-9` are a subset of both — so this is a widening and not a
+ * different tokenizer. It is a CORRECTNESS fix and not a lift claim, and the
+ * before/after reading over the trigger corpus train slice that says so is
+ * attached to the change that made it.
+ */
+const TOKEN_RE = /[\p{L}][\p{L}\p{N}]+/gu;
+/**
+ * Ported verbatim from the Python scorer. Order is irrelevant; membership is not.
+ *
+ * Kept as its own block rather than merged into the union below so that a
+ * reader can still see exactly what the parity scorer dropped, which is the
+ * thing the CLI parity suite pins.
+ */
+export const ENGLISH_STOPWORDS = new Set([
     'the', 'a', 'an', 'and', 'or', 'but', 'of', 'for', 'with', 'to', 'in',
     'on', 'at', 'by', 'from', 'as', 'is', 'are', 'was', 'were', 'be', 'been',
     'this', 'that', 'these', 'those', 'it', 'its', 'use', 'when', 'even',
@@ -46,6 +68,60 @@ export const STOPWORDS = new Set([
     'not', 'no', 'yes', 'any', 'some', 'all', 'one', 'two', 'new', 'old',
     'user', 'users', 'our', 'your', 'their', 'they', 'we', 'you', 'i', 'me',
 ]);
+/**
+ * The German block, beside the English one rather than inside it.
+ *
+ * WHY IT IS NEEDED AT ALL. The score is `|task ∩ skill| / |task|`, so a task
+ * term no skill indexes sits in the DENOMINATOR. Before the token class above
+ * was widened, a German function word mostly could not survive tokenization in
+ * one piece; now it can, and every one that does divides the whole score of
+ * every candidate. `das`, `die`, `der`, `und`, `für` carry no routing signal in
+ * either language and would otherwise be charged for.
+ *
+ * WHAT IS IN IT, AND WHAT IS DELIBERATELY NOT. Function words — articles,
+ * pronouns, conjunctions, prepositions, auxiliary and modal verbs — plus the
+ * direct counterparts of the generic verbs the English block already drops
+ * (`use`, `make`, `do`, `get`). Domain nouns are NOT in it: `fehler`, `test`,
+ * `datei` and `prüfung` are exactly the words a German prompt routes on, and
+ * mirroring the English block's `file` / `code` / `task` entries into German
+ * would delete the signal this change exists to recover.
+ *
+ * Six German words are left out because their English homograph is a routing
+ * term: `mit` (the licence), `bin` and `dir` (paths), `man` (pages), `war` and
+ * `des` (formats). A German prompt pays a little denominator for them.
+ *
+ * Words of three code points or fewer never reach this set — `tokenize` drops
+ * them first — so `in`, `am`, `zu`, `es` are listed nowhere and need not be.
+ */
+export const GERMAN_STOPWORDS = new Set([
+    'der', 'die', 'das', 'den', 'dem', 'ein', 'eine', 'einen', 'einem',
+    'einer', 'eines', 'und', 'oder', 'aber', 'sondern', 'denn', 'also',
+    'für', 'von', 'vom', 'zum', 'zur', 'auf', 'aus', 'bei', 'beim',
+    'nach', 'über', 'unter', 'durch', 'ohne', 'gegen', 'zwischen', 'vor',
+    'ist', 'sind', 'waren', 'bist', 'sein', 'seine', 'seiner',
+    'wird', 'werden', 'wurde', 'wurden', 'worden',
+    'hat', 'habe', 'haben', 'hatte', 'hatten',
+    'kann', 'kannst', 'können', 'könnte', 'soll', 'sollte', 'sollen',
+    'muss', 'müssen', 'darf', 'dürfen', 'will', 'wollen', 'möchte',
+    'wie', 'was', 'wer', 'wen', 'wem', 'wann', 'warum', 'wieso', 'weshalb',
+    'wenn', 'dass', 'weil', 'damit', 'ob',
+    'dies', 'diese', 'dieser', 'dieses', 'diesem', 'diesen',
+    'nicht', 'kein', 'keine', 'keinen', 'keiner', 'nichts',
+    'alle', 'allen', 'alles', 'auch', 'noch', 'nur', 'schon', 'sehr', 'mehr',
+    'hier', 'dort', 'jetzt', 'dann', 'immer', 'wieder',
+    'ich', 'mir', 'mich', 'dich', 'sie', 'ihr', 'ihre', 'ihren',
+    'wir', 'uns', 'euch', 'ihm', 'ihn', 'mein', 'meine', 'dein',
+    'bitte', 'mal', 'etwas', 'eigentlich', 'einfach',
+    // The counterparts of the English block's generic verbs. `mach` survives
+    // the three-code-point floor, so it is listed; `tu` does not and is not.
+    'mach', 'machen', 'macht', 'nutze', 'nutzen', 'verwende', 'verwenden',
+    'bekomme', 'bekommen', 'setze', 'setzen',
+]);
+/** The union both blocks are read through. One membership test, two sources. */
+export const STOPWORDS = new Set([
+    ...ENGLISH_STOPWORDS,
+    ...GERMAN_STOPWORDS,
+]);
 /** Mirror Python `len(str)` — count Unicode code points, not UTF-16 units. */
 function pyLen(s) {
     let n = 0;
@@ -65,7 +141,7 @@ export function roundHalfToEven(x) {
         return floor + 1;
     return floor % 2 === 0 ? floor : floor + 1;
 }
-/** Lowercase, extract `[a-z][a-z0-9]+`, drop stopwords and tokens of ≤2 code points. */
+/** Lowercase, extract `[\p{L}][\p{L}\p{N}]+`, drop stopwords and tokens of ≤2 code points. */
 export function tokenize(text) {
     const out = new Set();
     const matches = text.toLowerCase().match(TOKEN_RE) ?? [];
@@ -111,6 +187,28 @@ export function triggerTextFromFlatLines(lines) {
     }
     return out;
 }
+/**
+ * How many ranked rows `suggest_skill_for_task` returns when the caller names
+ * no limit — on BOTH servers, which is why it lives in the module both import.
+ *
+ * It was 5. The number is now pre-registered rather than chosen: the bar, fixed
+ * before the measurement was read, was "the smallest depth whose recall gain
+ * over 5 exceeds 5 points on the train slice of the trigger corpus", with 5
+ * staying and the step closing as an honest null if no depth cleared it.
+ *
+ * The committed run selects 8. Before the tokenizer widening, over 487
+ * positives, recall@5 was 0.620 and recall@8 0.686 — a gain of 6.6 points, the
+ * only candidate depth whose gain clears the bar at the smallest depth (10 adds
+ * 2.7 more, 20 another 6.5, neither of them the SMALLEST qualifying depth).
+ * With the widened tokenizer that ships, recall@5 is 0.622 and recall@8 0.684
+ * (+6.2 points), so the same bar still selects 8.
+ *
+ * Three more rows per call is the cost; each carries a description capped at
+ * 200 characters, so the ceiling it buys is bounded and paid only when the
+ * tool is actually called. Re-derive the figures with
+ * `measure_skill_ranker_baseline --corpus triggers-train`.
+ */
+export const DEFAULT_SUGGEST_LIMIT = 8;
 /** The indexed term set for one skill, under the given options. */
 export function skillTerms(skill, opts = {}) {
     const parts = [skill.name, skill.description];

package/dist/shared/userMd/formAdapter.js

@@ -16,6 +16,7 @@
  * when reading a partial or legacy file; validation runs server-side on
  * save via `userIdentitySchema`.
  */
+import { userStyleAvoidEntrySchema } from './schema.js';
 /**
  * Defaults for a fresh form. Matches `src/templates/agent-user.yml`:
  * `last_updated` is 1970-01-01 so any user-driven edit visibly bumps it.
@@ -48,6 +49,18 @@ function pickRoles(value) {
     // (role is optional; the wizard must not block setup on a role pick).
     return value.filter((v) => typeof v === 'string' && v.trim() !== '');
 }
+// Filtered per entry because a whole-list parse erased every entry on the next
+// save when one was invalid. The cap is not applied here: an over-cap list
+// survives so the server-side save rejects it with an error instead.
+function pickAvoid(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const kept = value.flatMap((entry) => {
+        const parsed = userStyleAvoidEntrySchema.safeParse(entry);
+        return parsed.success ? [parsed.data] : [];
+    });
+    return kept.length === 0 ? undefined : kept;
+}
 function pickNotes(value) {
     if (typeof value !== 'string')
         return undefined;
@@ -74,6 +87,9 @@ export function mergeIdentity(parsed) {
         voice_sample: pickString(parsed.voice_sample, def.voice_sample),
         last_updated: pickString(parsed.last_updated, def.last_updated),
     };
+    const avoid = pickAvoid(styleRaw.avoid);
+    if (avoid !== undefined)
+        out.style.avoid = avoid;
     if (notes !== undefined)
         out.notes = notes;
     return out;

package/dist/shared/userMd/schema.js

@@ -15,6 +15,17 @@ import { z } from 'zod';
 export const USER_IDENTITY_NOTES_MAX_CHARS = 8_000;
 /** Hard cap on the `voice_sample` block — one to three sentences in practice. */
 export const USER_IDENTITY_VOICE_SAMPLE_MAX_CHARS = 2_000;
+/** Cap on `style.avoid` entries (brand-checkability E16). */
+export const USER_IDENTITY_STYLE_AVOID_MAX_ENTRIES = 32;
+/** One "never say X" term, matched as an escaped literal — never a regex (NG-6). */
+export const userStyleAvoidEntrySchema = z.object({
+    pattern: z.string().trim().min(1, 'style.avoid pattern is required').max(64, 'style.avoid pattern exceeds 64 chars'),
+    match: z.enum(['word', 'substring']),
+    note: z.string().trim().min(1).optional(),
+});
+export const userStyleAvoidSchema = z
+    .array(userStyleAvoidEntrySchema)
+    .max(USER_IDENTITY_STYLE_AVOID_MAX_ENTRIES, `style.avoid exceeds ${USER_IDENTITY_STYLE_AVOID_MAX_ENTRIES} entries`);
 /** ISO-8601 date (`YYYY-MM-DD`) — `last_updated` is a date, not a timestamp. */
 const isoDate = z
     .string()
@@ -35,6 +46,9 @@ export const userIdentitySchema = z.object({
         // Formality is not configurable — the agent always addresses the user
         // informally ("Du"). Only `pace` remains tunable.
         pace: z.enum(['rapid', 'pragmatic', 'thorough']),
+        // Optional rather than `.default([])` so a file without it round-trips
+        // unchanged; read it through `userStyleAvoid`, whose default is `[]`.
+        avoid: userStyleAvoidSchema.optional(),
     }),
     // Optional — a writing sample sharpens tone mirroring but is not
     // required to save an identity (the setup wizard must not block on it).
@@ -50,4 +64,7 @@ export const userIdentitySchema = z.object({
         .max(USER_IDENTITY_NOTES_MAX_CHARS, 'notes exceeds hard cap')
         .optional(),
 });
+export function userStyleAvoid(identity) {
+    return identity.style.avoid ?? [];
+}
 //# sourceMappingURL=schema.js.map