@herjarsa/omo-meta-governor 0.52.0 → 0.53.0

package/dist/adherence.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Adherence tracking — detects when the agent IGNORES an already-injected
+ * directive (same rule violated again after the injection was drained).
+ *
+ * Why this exists: protocol violations are injected into the agent context
+ * (system.transform drain, FASE 11 11e), but nothing measured whether the
+ * agent actually complied afterwards. A repeat violation of the same rule
+ * AFTER the agent saw the directive is evidence of non-adherence, not of a
+ * missing directive — so it is counted separately (`directives_ignored`)
+ * instead of re-injecting louder each time.
+ *
+ * Lifecycle (per session):
+ *   1. tool.execute.before detects violation of rule R.
+ *   2. If R was already injected (drained) in this session → reincidencia:
+ *      `directives_ignored` + `adherence_ignored` log. Never escalates by
+ *      itself for leve/media (counting only — explicit below).
+ *   3. system.transform drains pendingViolations → each distinct rule R in
+ *      the drained items is recorded via `recordInjection` (injected = the
+ *      agent saw it; detection alone does NOT mark — the agent may never
+ *      have seen an undrained queue).
+ *   4. Scoring: ONLY grave reincidence with repeatCount >= 2 (third strike
+ *      counting the original) floors the decision to `stop`. The
+ *      stop → paralysis → continue loop stays supreme: a persistent false
+ *      positive still resolves via paralysisOverride forcing continue after
+ *      N consecutive stops, so adherence can never deadlock a session.
+ *
+ * Severity policy (explicit):
+ *   - leve / media reincidence: counted in `directives_ignored`, NEVER
+ *     escalates on its own. See `adherenceFloor` — it returns null for
+ *     non-grave severities unconditionally.
+ *   - grave reincidence: counted; escalates to `stop` ONLY at repeatCount
+ *     >= ADHERENCE_STOP_REPEAT_THRESHOLD (2). Below that, the Wave B grave
+ *     floor (continue/warn → escalate) still applies as before.
+ *
+ * All helpers here are pure (no I/O, no Date.now, no globals) so they are
+ * unit-testable without the plugin factory.
+ */
+/** Rule -> times the rule's directive was drained (seen by the agent). */
+export type InjectedRules = Record<string, number>;
+/**
+ * How many times a rule's directive was already injected when a new
+ * violation arrives. repeatCount >= ADHERENCE_STOP_REPEAT_THRESHOLD means
+ * the third strike (original + 2 repeats).
+ */
+export declare const ADHERENCE_STOP_REPEAT_THRESHOLD = 2;
+/** Cap of distinct rules tracked per session (bounds per-session memory). */
+export declare const ADHERENCE_MAX_RULES = 50;
+/**
+ * Record that rule `rule` was injected (drained into agent context).
+ * Returns a NEW record (input is not mutated). When the record already
+ * holds ADHERENCE_MAX_RULES distinct rules, the new rule is dropped so a
+ * noisy session cannot grow memory unboundedly.
+ */
+export declare function recordInjection(rules: Readonly<InjectedRules>, rule: string): InjectedRules;
+/**
+ * How many times `rule` was already injected in this session (0 = never —
+ * the current violation is the first occurrence, NOT a reincidencia).
+ */
+export declare function countRepeat(rules: Readonly<InjectedRules>, rule: string): number;
+/**
+ * Adherence escalation floor. Returns "stop" ONLY for grave reincidence at
+ * or above the repeat threshold. leve/media ALWAYS return null (counted,
+ * never escalated — see module docstring). Unknown severities return null.
+ */
+export declare function adherenceFloor(severity: string, repeatCount: number): "stop" | null;
+/**
+ * Extract distinct rule names from drained violation entry strings.
+ * Entries are formatted as `[SEVERITY] rule: detail` (see plugin.ts queue
+ * site). Returns distinct rules in first-seen order; unparseable entries
+ * are skipped (never throw — drain is best-effort).
+ */
+export declare function parseInjectedRules(items: readonly string[]): string[];

package/dist/config.d.ts

@@ -90,11 +90,13 @@ export interface MetaGovernorPluginConfig {
      *   Even stop-level decisions log without injecting an Oracle prompt.
      *   Zero mid-work interruptions.
      *
-     * - `"per-stop"`: Oracle is invoked ONLY at the final-gate
-     *   (`<promise>DONE</promise>`) AND when score crosses the stop
-     *   threshold (`≤ -stopThreshold`). warn/escalate decisions log but do
-     *   NOT inject an Oracle prompt mid-work. Brake on emergencies,
-     *   mandatory at done.
+     * - `"per-stop"`: Oracle is invoked at the final-gate
+     *   (`<promise>DONE</promise>`) AND when the scoring engine reaches the
+     *   stop band (action === "stop"). warn/escalate decisions log but do
+     *   NOT invoke Oracle mid-work. Brake on emergencies, mandatory at done.
+     *   (B3: wording copied from enforcement-resources.ts buildOracleRule;
+     *   the previous text said "ONLY at the final-gate ... AND when",
+     *   which is self-contradictory.)
      *
      * - `"off"`: Oracle is never invoked. The post-wave gate still requires
      *   `oracleVerified` — set it manually via `omo_recall` if you need it.