@herjarsa/omo-meta-governor 0.52.0 → 0.54.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/closed-loop-learning.d.ts

@@ -37,6 +37,17 @@ export declare function lessonConfidenceForDecision(decision: Decision): number;
 export declare function isNeutralContinueDecision(decision: Decision): boolean;
 /** Severity ordering for threshold comparison. */
 declare const SEVERITY_ORDER: Record<string, number>;
+/**
+ * Extract concepts from deviations for the lesson. Optionally include file
+ * basenames from the broader filePaths list so FTS indexing covers all
+ * recently changed files (Gap Q completeness, v0.17.2).
+ *
+ * v0.53.1 (conscience-content fix): exported for reuse by the auto-remember
+ * path so concepts derive from REAL rule deviations (categories + basenames)
+ * instead of the generic ['conscience','media'] pair. Generic concepts
+ * pollute FTS recall with noise; real categories keep recall precise.
+ */
+export declare function extractConcepts(deviations: readonly Deviation[], filesChanged?: readonly string[]): string[];
 /**
  * Core learning function. Decides whether to save a lesson and/or decision
  * to agentmemory based on the outcome of a repair/action cycle.
@@ -78,19 +89,62 @@ export interface ConscienceDedupeKeyInput {
     readonly deviationCategories: readonly string[];
 }
 export declare function conscienceDedupeKey(input: ConscienceDedupeKeyInput): string;
+/**
+ * Basename for FTS indexing — handles POSIX and Windows separators.
+ * Keeps whereToGo/concepts as real PLACES (file names) instead of
+ * meta-instructions about which tool to call.
+ */
+export declare function basenameOf(filePath: string): string;
+/**
+ * Derive the conscience `mistake` from REAL rule deviations — never the raw
+ * scoring reasoning. A raw dump like 'Stop (score: -0.552): primary concern:
+ * Iteration ratio...' describes the JUDGE ('the session is long'), not a
+ * learnable rule violation. The learnable unit is `${category}: ${detail}`
+ * from the first non-conscience deviation; when several exist they are joined
+ * with '; ' and truncated to ~300 chars so the saved lesson stays scannable.
+ */
+export declare function conscienceMistakeFromDeviations(deviations: readonly Deviation[]): string;
+/**
+ * Derive conscience `whereToGo` as a PLACE — basenames of changed files —
+ * never meta-instructions. The old value ('Persist via omo_remember; recall
+ * via omo_recall...') told the agent WHERE in tool-space, not where in the
+ * repo the rule applies. When no files exist, `session:<id>` scopes the
+ * lesson to the session instead of inventing a location.
+ */
+export declare function conscienceWhereToGo(files: readonly string[], sessionID: string): string;
 /**
  * Structured conscience memory content (D4/D6). Built via buildLessonContent
  * + extractConcepts — never a raw dump. Delivery route is always the
  * Zod-validated omo_remember tool.
+ *
+ * v0.53.1 (conscience-content fix): content is pure lesson — no `ToolRoute:`
+ * self-reference. The agent already knows the tool from the preamble
+ * ('Conscience lesson — persist it via omo_remember'); persisting the route
+ * inside the lesson pollutes recall with meta-instructions. `toolRoute` is
+ * kept as an optional deprecated passthrough so old callers still compile,
+ * but it is NEVER rendered. Concepts derive from REAL deviations via
+ * extractConcepts, not the generic ['conscience','media'] pair.
  */
 export interface BuildConscienceMemoryContentInput {
     readonly action: "escalate" | "stop";
     readonly mistake: string;
     readonly whatToDo: string;
     readonly whereToGo: string;
-    readonly toolRoute: "omo_remember";
+    /**
+     * Deprecated self-reference — accepted for compat but never rendered.
+     * The preamble already names omo_remember; the saved CONTENT must be
+     * pure lesson (mistake/whatToDo/whereToGo) without tool routing noise.
+     */
+    readonly toolRoute?: "omo_remember";
     readonly score: number;
     readonly files: readonly string[];
+    /**
+     * Real rule deviations (category !== 'conscience'). Used for the lesson
+     * base + concepts so recall indexes violated rules, not the synthetic
+     * conscience wrapper. When omitted, falls back to the legacy synthetic
+     * single-deviation for backward compat with direct unit callers.
+     */
+    readonly deviations?: readonly Deviation[];
 }
 export interface ConscienceMemoryContent {
     readonly content: 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.

package/dist/health.d.ts

@@ -32,6 +32,7 @@ export interface PluginHealth {
         /** v0.35.0 (Tier 3 watcher): count of new SKILL.md files detected under
          *  cwd/.agents/skills/. Increments per create/write event from chokidar. */
         tier3SkillsCreated: number;
+        directivesIgnored: number;
         lastDecisionISO: string | null;
         lastInterventionISO: string | null;
     };