@event4u/agent-config 10.1.0 → 10.3.0

package/src/server/schemas/settings.ts

@@ -21,7 +21,6 @@ const userType = z.enum(['', 'consultant', 'creator', 'developer', 'finance', 'f
 const profileId = z.enum(['developer', 'content_creator', 'founder', 'agency', 'finance', 'ops']);
 const accessStyle = z.enum(['getters_setters', 'get_attribute', 'magic_properties']);
 const chatFreq = z.enum(['per_turn', 'per_phase', 'per_tool']);
-const chatOverflow = z.enum(['rotate', 'condense']);
 const qualityCadence = z.enum(['end_of_roadmap', 'per_phase', 'per_step']);
 const regenCadence = z.enum(['per_step', 'every_5_steps', 'phase_boundary']);
 const worktreeMode = z.enum(['off', 'on', 'ask']);
@@ -169,12 +168,6 @@ export const settingsSchema = z.object({
         frequency: chatFreq.default('per_turn').describe(
             'How often the chat-history writer flushes to disk. per_turn = after every user / agent exchange (default, lowest data loss on crash). per_phase = at phase boundaries (cheaper I/O). per_tool = after every tool call (highest fidelity, noisiest log).',
         ),
-        max_size_kb: z.number().int().min(0).default(2048).describe(
-            'Maximum size (KB) of the active chat-history file before chat_history.on_overflow kicks in. Set 0 to disable rotation / condensation entirely (file grows forever).',
-        ),
-        on_overflow: chatOverflow.default('rotate').describe(
-            'What happens when chat_history.max_size_kb is hit. rotate = move the current log aside and start fresh (default). condense = telegraph-condense the oldest entries in place to keep recent context.',
-        ),
         text_limits: z.object({
             user: z.number().int().min(0).default(0).describe(
                 'Per-message character cap for user inputs in the chat-history log. 0 = log verbatim (default). Raise above 0 only if your prompts contain large pasted artefacts you do not want stored.',
@@ -231,9 +224,6 @@ export const settingsSchema = z.object({
         local_auto_run: z.boolean().default(false).describe(
             'Run quality tools (linters, type-checks, formatters) and the local test suite autonomously after edits. Off by default — the agent never runs quality tools proactively and does not ask; the user runs them manually (e.g. /quality-fix) and remote CI is the authoritative gate. The agent only runs a quality tool on an explicit ask, a concrete CI failure, or the new-gate carve-out. Turn on to restore autonomous pipeline runs.',
         ),
-        wait_for_remote_ci: z.boolean().default(false).describe(
-            'After pushing a branch, poll the remote CI provider (GitHub Actions, GitLab CI) and surface failures inline. Off by default — useful when local CI does not cover everything the remote pipeline runs.',
-        ),
     }),
     design: z.object({
         fidelity_mode: fidelityMode.default('strict').describe(
@@ -258,12 +248,9 @@ export const settingsSchema = z.object({
     }).default({ identity_allowlist: [], forbid_terminal_capture: true, data_bearing_gate: 'on' }),
     telegraph: z.object({
         speak: z.boolean().default(false).describe(
-            'Whether the telegraph-speak rule ships at all. false (default) = DORMANT: compile_router omits the rule from dist/router.json entirely, so its body never reaches a host. This — not speak_scope — is the lever that stops the cost. Set true only after an output-side bench clears the kill-criterion bar (docs/adrs/telegraph/0002).',
+            'Whether the telegraph-speak rule ships at all. false (default) = DORMANT: compile_router omits the rule from dist/router.json entirely, so its body never reaches a host. This is the only lever that stops the cost. Set true only after an output-side bench clears the kill-criterion bar (docs/adrs/telegraph/0002).',
         ),
-        speak_scope: z.enum(['off', 'reply', 'all']).default('off').describe(
-            "Where telegraph condensation applies WHEN speak is true. off (default) = agent reply prose is exempt. compile_router never reads this key: with speak false the rule does not ship, so this setting has no effect on its own. Quote the value in YAML — bare `off` parses as a boolean under YAML 1.1 and is rejected.",
-        ),
-    }).default({ speak: false, speak_scope: 'off' }),
+    }).default({ speak: false }),
     tokens: z.object({
         rich_skills: richSkillsMode.default('on').describe(
             'Whether skills marked token_budget_class: rich may load in full (exempt from telegraph-speak + thin-projector trimming), consumed by the token-budget-discipline rule. on = allowed (default); off = fall back to standard condensed behavior; ask = surface an estimated token delta (tokens, not dollars) and ask once per session before loading.',
@@ -573,13 +560,10 @@ export const settingsSchema = z.object({
         acknowledged: z.boolean().default(false).describe(
             'I understand the legal-review-prep pack provides templates and general information ONLY — it is NOT legal advice, creates no attorney-client relationship, and never replaces a licensed lawyer. Individual cases require an attorney. The pack stays inactive until this is checked.',
         ),
-        consented_at: z.string().default('').describe(
-            'ISO timestamp recorded when the legal-review-prep acknowledgment was given. Set automatically by the setup wizard; leave empty otherwise.',
-        ),
         require_council: z.boolean().default(true).describe(
             'Gate legal work-product behind a multi-model AI-council / deep-research pass (defense-in-depth: documented multi-stage review + audit trail; fail-closed when no council is configured). Leave on for the safest posture. Turning it off lets single-model legal output through — not recommended for a high-risk pack.',
         ),
-    }).default({ acknowledged: false, consented_at: '', require_council: true }),
+    }).default({ acknowledged: false, require_council: true }),
 });
 
 export type Settings = z.infer<typeof settingsSchema>;

package/src/shared/settingsClasses.ts

@@ -24,16 +24,61 @@ export function isSettingsClass(value: string): value is SettingsClass {
     return (SETTINGS_CLASSES as readonly string[]).includes(value);
 }
 
+/**
+ * The closed disposition vocabulary — the axis orthogonal to A/B/C.
+ *
+ * A/B/C answers *who may write a key*. This answers *whether the key should
+ * exist at all*, which is a different question with a different action per
+ * value. A row outside the vocabulary is a defect, not a new disposition.
+ */
+export const SETTINGS_DISPOSITIONS = ['derivable', 'un-inferrable', 'consent', 'policy'] as const;
+
+export type SettingsDisposition = (typeof SETTINGS_DISPOSITIONS)[number];
+
+export function isSettingsDisposition(value: string): value is SettingsDisposition {
+    return (SETTINGS_DISPOSITIONS as readonly string[]).includes(value);
+}
+
 /** One parsed row of the contract's key table. */
 export interface SettingsClassRow {
     /** Dotted leaf path, e.g. `personal.autonomy`. */
     key: string;
     /** Raw class cell — NOT yet validated, so the lint can report a bad one. */
     cls: string;
+    /**
+     * Raw disposition cell, or `null` when the row has no fifth column at all.
+     *
+     * NOT validated here, for the same reason `cls` is not: the lint has to be
+     * able to report a bad value, and a parser that silently drops it would
+     * make an unclassified key indistinguishable from a mis-spelled one.
+     *
+     * `derivable` rows carry their replacement after an em dash — the clause
+     * that makes the label falsifiable rather than a synonym for "inconvenient
+     * to keep". `dispositionOf` returns the label, `replacementOf` the clause.
+     */
+    disposition: string | null;
     /** 1-indexed line in the contract, so a finding points at something. */
     line: number;
 }
 
+/** `derivable — the detector's own trigger condition` → `derivable`. */
+export function dispositionOf(cell: string | null): string | null {
+    if (cell === null) {
+        return null;
+    }
+    const [label] = cell.split('—');
+    return (label ?? '').trim();
+}
+
+/** `derivable — the detector's own trigger condition` → the clause after the dash. */
+export function replacementOf(cell: string | null): string {
+    if (cell === null) {
+        return '';
+    }
+    const dash = cell.indexOf('—');
+    return dash === -1 ? '' : cell.slice(dash + 1).trim();
+}
+
 /** What the contract's own `## Counts` table claims about itself. */
 export interface DeclaredClassCounts {
     A: number | null;
@@ -51,11 +96,20 @@ export interface DeclaredClassCounts {
  */
 const ROW_RE = /^\|\s*`([^`]+)`\s*\|\s*([^|]*?)\s*\|/;
 
+/**
+ * The disposition is read as the FIFTH cell, appended after `Why`, so the four
+ * cells every existing consumer indexes keep their positions. A row that
+ * predates the axis simply has no fifth cell and parses to `null` — an absent
+ * disposition, which the lint reports, rather than a shifted `Default`.
+ */
+const DISPOSITION_RE = /^\|\s*`[^`]+`\s*\|[^|]*\|[^|]*\|[^|]*\|\s*([^|]*?)\s*\|/;
+
 export function parseSettingsClassRows(markdown: string): SettingsClassRow[] {
     const rows: SettingsClassRow[] = [];
     const lines = markdown.split('\n');
     for (let i = 0; i < lines.length; i++) {
-        const m = ROW_RE.exec(lines[i] ?? '');
+        const line = lines[i] ?? '';
+        const m = ROW_RE.exec(line);
         if (m === null) {
             continue;
         }
@@ -64,7 +118,9 @@ export function parseSettingsClassRows(markdown: string): SettingsClassRow[] {
         if (!/^[A-Za-z]$/.test(cls)) {
             continue;
         }
-        rows.push({ key, cls, line: i + 1 });
+        const d = DISPOSITION_RE.exec(line);
+        const raw = d?.[1] ?? '';
+        rows.push({ key, cls, disposition: raw === '' ? null : raw, line: i + 1 });
     }
     return rows;
 }
@@ -84,6 +140,41 @@ export function parseDeclaredClassCounts(markdown: string): DeclaredClassCounts
     };
 }
 
+/** What the contract's own `## Dispositions` table claims about itself. */
+export interface DeclaredDispositionCounts {
+    derivable: number | null;
+    'un-inferrable': number | null;
+    consent: number | null;
+    policy: number | null;
+    total: number | null;
+}
+
+/** `| derivable | 12 |` and `| **Total** | **140** |` under `## Dispositions`. */
+export function parseDeclaredDispositionCounts(markdown: string): DeclaredDispositionCounts {
+    // Scoped to the section, so the class Counts table's own **Total** row —
+    // identical in shape and earlier in the file — cannot be read as this one.
+    const start = markdown.indexOf('\n## Dispositions');
+    const section = start === -1 ? '' : markdown.slice(start + 1);
+    const end = section.indexOf('\n## ', 1);
+    const scoped = end === -1 ? section : section.slice(0, end);
+    // The value cell is read with optional `**` so the bolded `**Total**` row
+    // and the plain per-label rows go through one path — a second regex for the
+    // total is a second thing to get wrong.
+    const read = (label: string): number | null => {
+        const re = new RegExp(String.raw`^\|\s*` + label + String.raw`\s*\|\s*\**(\d+)\**\s*\|`, 'm');
+        const m = re.exec(scoped);
+        const raw = m?.[1];
+        return raw === undefined ? null : Number.parseInt(raw, 10);
+    };
+    return {
+        derivable: read('derivable'),
+        'un-inferrable': read('un-inferrable'),
+        consent: read('consent'),
+        policy: read('policy'),
+        total: read(String.raw`\*\*Total\*\*`),
+    };
+}
+
 /**
  * Dotted key → class, for the rows whose class is valid.
  *