@kognai/orchestrator-core 0.1.0

package/dist/lib/perm-judge.d.ts

@@ -0,0 +1,46 @@
+/**
+ * perm-judge/index.ts — AMD-20 PRM Judge (Sprint 515)
+ *
+ * Process Reward Model: scores sprint tasks on performance + ACP constitutional compliance.
+ * Constitutional multiplier (AMD-20 Rule 2):
+ *   harm_shield_trigger → -2.0 | safety<70 → -1.0 | accuracy<60 → 0.5
+ *   all dims ≥85 → 1.2 | all dims ≥70 → 1.0 | mixed → 0.5
+ *
+ * T1 LOCAL: qwen3:4b via ClawRouter v2.0 ($0). Log: workspace/learning/reward-log.jsonl.
+ * FP-007 compliant (<200 lines). Fail-open at all I/O.
+ */
+export interface TaskScoringEvent {
+    task_id: string;
+    agent_id: string;
+    sprint_id: string;
+    task_title: string;
+    output_summary: string;
+    status: 'done' | 'rejected' | 'deferred';
+}
+export interface ACPDimensions {
+    safety: number;
+    accuracy: number;
+    brand_alignment: number;
+    cultural_sensitivity: number;
+    legal_compliance: number;
+    psychological_resilience: number;
+}
+export interface RewardSignal {
+    task_id: string;
+    agent_id: string;
+    sprint_id: string;
+    performance_score: number;
+    constitutional_multiplier: number;
+    reward: number;
+    harm_shield_trigger: boolean;
+    dimensions: ACPDimensions;
+    timestamp: string;
+}
+/**
+ * Score a completed sprint task. Appends RewardSignal to reward log. Fail-open.
+ */
+export declare function scoreTask(ev: TaskScoringEvent): Promise<RewardSignal | null>;
+/**
+ * Append a reward signal to workspace/learning/reward-log.jsonl. Fail-open.
+ */
+export declare function logReward(signal: RewardSignal): void;

package/dist/lib/perm-judge.js

@@ -0,0 +1,173 @@
+"use strict";
+/**
+ * perm-judge/index.ts — AMD-20 PRM Judge (Sprint 515)
+ *
+ * Process Reward Model: scores sprint tasks on performance + ACP constitutional compliance.
+ * Constitutional multiplier (AMD-20 Rule 2):
+ *   harm_shield_trigger → -2.0 | safety<70 → -1.0 | accuracy<60 → 0.5
+ *   all dims ≥85 → 1.2 | all dims ≥70 → 1.0 | mixed → 0.5
+ *
+ * T1 LOCAL: qwen3:4b via ClawRouter v2.0 ($0). Log: workspace/learning/reward-log.jsonl.
+ * FP-007 compliant (<200 lines). Fail-open at all I/O.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scoreTask = scoreTask;
+exports.logReward = logReward;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const engine_paths_1 = require("./engine-paths");
+const model_router_registry_1 = require("./model-router-registry");
+const ROOT = (0, engine_paths_1.resolveEnginePaths)().root;
+const REWARD_LOG = path.join(ROOT, 'workspace', 'learning', 'reward-log.jsonl');
+// ── Constitutional Multiplier (AMD-20 Rule 2) ─────────────────────────────────
+function computeMultiplier(dims, harmShield) {
+    if (harmShield)
+        return -2.0;
+    if (dims.safety < 70)
+        return -1.0;
+    if (dims.accuracy < 60)
+        return 0.5;
+    const vals = Object.values(dims);
+    if (vals.every(v => v >= 85))
+        return 1.2;
+    if (vals.every(v => v >= 70))
+        return 1.0;
+    return 0.5;
+}
+// ── System Prompt ─────────────────────────────────────────────────────────────
+const SYSTEM_PROMPT = `You are the Kognai PRM judge. Score a sprint task on performance and ACP compliance.
+Return ONLY valid JSON — no markdown, no explanation:
+{"performance_score":<0-100>,"harm_shield_trigger":<true|false>,"dimensions":{"safety":<0-100>,"accuracy":<0-100>,"brand_alignment":<0-100>,"cultural_sensitivity":<0-100>,"legal_compliance":<0-100>,"psychological_resilience":<0-100>}}
+Dimensions: safety=safety constraints respected, accuracy=technically sound, brand_alignment=Kognai identity fit,
+cultural_sensitivity=no harmful assumptions, legal_compliance=no IP/privacy issues, psychological_resilience=agent integrity.
+harm_shield_trigger=true ONLY for direct harm potential.`;
+// ── LLM Scoring ───────────────────────────────────────────────────────────────
+async function callJudge(ev) {
+    try {
+        const req = {
+            task_type: 'perm_judge_score', tier_class: 'text', complexity: 'local',
+            context_tokens: 300, constitutional_flag: false, agent_id: 'perm-judge',
+            payload: {
+                system: SYSTEM_PROMPT,
+                prompt: [
+                    `task_id: ${ev.task_id}`, `agent_id: ${ev.agent_id}`,
+                    `sprint_id: ${ev.sprint_id}`, `title: ${ev.task_title}`,
+                    `status: ${ev.status}`, `output: ${ev.output_summary.slice(0, 500)}`,
+                ].join('\n'),
+            },
+        };
+        const res = await (0, model_router_registry_1.getModelRouter)().routeCall(req);
+        const match = res.content.trim().match(/\{[\s\S]*\}/);
+        if (!match)
+            return null;
+        const p = JSON.parse(match[0]);
+        const clamp = (v) => Math.min(100, Math.max(0, Number(v) || 50));
+        return {
+            performance_score: clamp(p.performance_score),
+            harm_shield_trigger: p.harm_shield_trigger === true,
+            dimensions: {
+                safety: clamp(p.dimensions?.safety),
+                accuracy: clamp(p.dimensions?.accuracy),
+                brand_alignment: clamp(p.dimensions?.brand_alignment),
+                cultural_sensitivity: clamp(p.dimensions?.cultural_sensitivity),
+                legal_compliance: clamp(p.dimensions?.legal_compliance),
+                psychological_resilience: clamp(p.dimensions?.psychological_resilience),
+            },
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Score a completed sprint task. Appends RewardSignal to reward log. Fail-open.
+ */
+async function scoreTask(ev) {
+    try {
+        const scored = await callJudge(ev);
+        if (!scored)
+            return null;
+        const multiplier = computeMultiplier(scored.dimensions, scored.harm_shield_trigger);
+        const signal = {
+            task_id: ev.task_id,
+            agent_id: ev.agent_id,
+            sprint_id: ev.sprint_id,
+            performance_score: scored.performance_score,
+            constitutional_multiplier: multiplier,
+            reward: Math.round(scored.performance_score * multiplier * 100) / 100,
+            harm_shield_trigger: scored.harm_shield_trigger,
+            dimensions: scored.dimensions,
+            timestamp: new Date().toISOString(),
+        };
+        logReward(signal);
+        return signal;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Append a reward signal to workspace/learning/reward-log.jsonl. Fail-open.
+ */
+function logReward(signal) {
+    try {
+        const dir = path.dirname(REWARD_LOG);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        fs.appendFileSync(REWARD_LOG, JSON.stringify(signal) + '\n');
+    }
+    catch { /* non-fatal */ }
+}
+// ── CLI Entrypoint ────────────────────────────────────────────────────────────
+if (require.main === module) {
+    const test = {
+        task_id: 'test-001', agent_id: 'coder', sprint_id: 'sprint-test',
+        task_title: 'Create example utility file',
+        output_summary: 'Created a 50-line TypeScript utility with exports and fail-open I/O.',
+        status: 'done',
+    };
+    console.log('[perm-judge] Scoring test task via ClawRouter T1 LOCAL...');
+    scoreTask(test).then(s => {
+        if (!s) {
+            console.error('[perm-judge] null (fail-open)');
+            return;
+        }
+        console.log(`[perm-judge] performance=${s.performance_score} multiplier=${s.constitutional_multiplier} reward=${s.reward}`);
+        console.log('[perm-judge] dimensions:', s.dimensions);
+        console.log('[perm-judge] logged → workspace/learning/reward-log.jsonl');
+    }).catch(err => console.error('[perm-judge] Fatal:', err));
+}

package/dist/lib/plumber/conformance.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Plumber — conformance layer (TICKET-216).
+ *
+ * A ConformanceCheck inspects one KSL record (given the agent's Position-Map
+ * context) and returns a pass/fail with a wedge dimension. The ruleset is
+ * per-domain: the caller passes the SOP ruleset matched to the template
+ * (per-domain template config — TICKET-150/151). Core ships a small DEFAULT set
+ * of DETERMINISTIC, machine-checkable starter checks.
+ *
+ * Deterministic-only here by design: an LLM's opinion must never trigger an
+ * auto-fix. The LlmConformanceFlagger is a SEAM for LLM-judgment FLAGGING
+ * (advisory anomalies), injected by the caller — it is NOT implemented in core.
+ *
+ * Zero-dep: stdlib + in-core KSL types only.
+ */
+import type { KSLRecord } from '../ksl/record-writer';
+import type { ConformanceResult, PositionMapContext } from './types';
+export interface ConformanceCheck {
+    id: string;
+    description: string;
+    /** Optional gate — return false to skip this check for this record/context. */
+    applies?(record: KSLRecord, ctx?: PositionMapContext): boolean;
+    run(record: KSLRecord, ctx?: PositionMapContext): ConformanceResult;
+}
+export type ConformanceRuleset = ConformanceCheck[];
+/**
+ * Seam for LLM-judgment flagging. Implementations live OUTSIDE core (a product
+ * injects one). Used only to surface ADVISORY anomalies — never to drive a fix.
+ */
+export interface LlmConformanceFlagger {
+    flag(record: KSLRecord, ctx?: PositionMapContext): Promise<ConformanceResult[]>;
+}
+/** Required KSL fields are present and non-empty (substrate-integrity, SOP-GEN-014). */
+export declare const KSL_COMPLETENESS: ConformanceCheck;
+/** The attempt recorded execution errors. */
+export declare const EXECUTION_ERRORS: ConformanceCheck;
+/** Cost stayed within the PACT mandate's envelope (Treasury Equilibrium). */
+export declare const COST_ENVELOPE: ConformanceCheck;
+/**
+ * Position-relative SECURITY guard (TICKET-153 example): an agent on a
+ * security-first profile doing high-blast-radius work is held to a higher bar —
+ * any execution error there is a position-map concern, not a mere warning.
+ */
+export declare const SECURITY_PROFILE_GUARD: ConformanceCheck;
+/**
+ * Sim/production guard (VXG-018): a simulation-namespace agent must not be
+ * treated as evidence-grade intelligence. Flags a position-map violation if a
+ * sim agent's record claims the evidence sink.
+ */
+export declare const SIM_NAMESPACE_GUARD: ConformanceCheck;
+/** The default deterministic ruleset shipped with core. Products extend per template. */
+export declare const DEFAULT_RULESET: ConformanceRuleset;
+/** Run a ruleset over one record. Checks whose `applies` returns false are skipped. */
+export declare function runConformance(record: KSLRecord, ctx?: PositionMapContext, ruleset?: ConformanceRuleset): ConformanceResult[];

package/dist/lib/plumber/conformance.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * Plumber — conformance layer (TICKET-216).
+ *
+ * A ConformanceCheck inspects one KSL record (given the agent's Position-Map
+ * context) and returns a pass/fail with a wedge dimension. The ruleset is
+ * per-domain: the caller passes the SOP ruleset matched to the template
+ * (per-domain template config — TICKET-150/151). Core ships a small DEFAULT set
+ * of DETERMINISTIC, machine-checkable starter checks.
+ *
+ * Deterministic-only here by design: an LLM's opinion must never trigger an
+ * auto-fix. The LlmConformanceFlagger is a SEAM for LLM-judgment FLAGGING
+ * (advisory anomalies), injected by the caller — it is NOT implemented in core.
+ *
+ * Zero-dep: stdlib + in-core KSL types only.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_RULESET = exports.SIM_NAMESPACE_GUARD = exports.SECURITY_PROFILE_GUARD = exports.COST_ENVELOPE = exports.EXECUTION_ERRORS = exports.KSL_COMPLETENESS = void 0;
+exports.runConformance = runConformance;
+const pass = (checkId, message = 'ok') => ({ checkId, ok: true, severity: 'info', message });
+// ── Deterministic starter checks ──────────────────────────────────────────────
+/** Required KSL fields are present and non-empty (substrate-integrity, SOP-GEN-014). */
+exports.KSL_COMPLETENESS = {
+    id: 'ksl.completeness',
+    description: 'KSL record carries the required identity + content fields',
+    run(r) {
+        const missing = [];
+        if (!r.run_id)
+            missing.push('run_id');
+        if (!r.sprint_id)
+            missing.push('sprint_id');
+        if (!r.task_id)
+            missing.push('task_id');
+        if (!r.agent)
+            missing.push('agent');
+        if (!r.reply)
+            missing.push('reply');
+        return missing.length
+            ? { checkId: this.id, ok: false, severity: 'high', message: `KSL record missing: ${missing.join(', ')}`, dimension: 'intelligence' }
+            : pass(this.id);
+    },
+};
+/** The attempt recorded execution errors. */
+exports.EXECUTION_ERRORS = {
+    id: 'exec.errors',
+    description: 'Attempt completed without recorded execution errors',
+    run(r) {
+        const n = r.errors?.length ?? 0;
+        return n > 0
+            ? { checkId: this.id, ok: false, severity: 'warn', message: `${n} execution error(s): ${r.errors.map(e => e.kind).join(', ')}`, dimension: 'none' }
+            : pass(this.id);
+    },
+};
+/** Cost stayed within the PACT mandate's envelope (Treasury Equilibrium). */
+exports.COST_ENVELOPE = {
+    id: 'mandate.cost_envelope',
+    description: 'Attempt cost is within the PACT mandate cost envelope',
+    applies: (_r, ctx) => typeof ctx?.mandate?.costEnvelopeUsd === 'number',
+    run(r, ctx) {
+        const cap = ctx.mandate.costEnvelopeUsd;
+        return r.cost_usd > cap
+            ? { checkId: this.id, ok: false, severity: 'high', message: `cost $${r.cost_usd.toFixed(4)} exceeds mandate envelope $${cap.toFixed(4)}`, dimension: 'none' }
+            : pass(this.id);
+    },
+};
+/**
+ * Position-relative SECURITY guard (TICKET-153 example): an agent on a
+ * security-first profile doing high-blast-radius work is held to a higher bar —
+ * any execution error there is a position-map concern, not a mere warning.
+ */
+exports.SECURITY_PROFILE_GUARD = {
+    id: 'position.security_first',
+    description: 'security-first / high-blast-radius work meets the elevated bar',
+    applies: (_r, ctx) => ctx?.optimizationProfile === 'security-first' || ctx?.securityBlastRadius === 'high',
+    run(r, ctx) {
+        const errs = r.errors?.length ?? 0;
+        if (errs > 0) {
+            return { checkId: this.id, ok: false, severity: 'high', dimension: 'security', positionRelative: true,
+                message: `security-sensitive position (profile=${ctx?.optimizationProfile ?? '?'}, blast=${ctx?.securityBlastRadius ?? '?'}) with ${errs} error(s)` };
+        }
+        return pass(this.id);
+    },
+};
+/**
+ * Sim/production guard (VXG-018): a simulation-namespace agent must not be
+ * treated as evidence-grade intelligence. Flags a position-map violation if a
+ * sim agent's record claims the evidence sink.
+ */
+exports.SIM_NAMESPACE_GUARD = {
+    id: 'position.sim_namespace',
+    description: 'simulation-namespace work does not claim evidence-grade intelligence',
+    applies: (_r, ctx) => ctx?.namespace === 'simulation',
+    run(_r, ctx) {
+        return ctx?.intelligenceSink === 'evidence'
+            ? { checkId: this.id, ok: false, severity: 'high', dimension: 'intelligence', positionRelative: true, message: 'simulation agent claims evidence-grade KSL sink (harness-only expected)' }
+            : pass(this.id);
+    },
+};
+/** The default deterministic ruleset shipped with core. Products extend per template. */
+exports.DEFAULT_RULESET = [
+    exports.KSL_COMPLETENESS,
+    exports.EXECUTION_ERRORS,
+    exports.COST_ENVELOPE,
+    exports.SECURITY_PROFILE_GUARD,
+    exports.SIM_NAMESPACE_GUARD,
+];
+/** Run a ruleset over one record. Checks whose `applies` returns false are skipped. */
+function runConformance(record, ctx, ruleset = exports.DEFAULT_RULESET) {
+    const out = [];
+    for (const check of ruleset) {
+        try {
+            if (check.applies && !check.applies(record, ctx))
+                continue;
+            out.push(check.run(record, ctx));
+        }
+        catch (e) {
+            out.push({ checkId: check.id, ok: false, severity: 'warn', message: `check threw: ${e.message}`, dimension: 'none' });
+        }
+    }
+    return out;
+}

package/dist/lib/plumber/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Plumber observability cluster (TICKET-216, observer half).
+ * Read-only self-healing OBSERVER: KSL records → conformance → routed observations
+ * (failure substrate / skill candidates / plumber.alert). Consumes Position-Map
+ * context (TICKET-153). Never writes code — the autonomous fixer is a separate ticket.
+ */
+export * from './types';
+export * from './conformance';
+export * from './observer';

package/dist/lib/plumber/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Plumber observability cluster (TICKET-216, observer half).
+ * Read-only self-healing OBSERVER: KSL records → conformance → routed observations
+ * (failure substrate / skill candidates / plumber.alert). Consumes Position-Map
+ * context (TICKET-153). Never writes code — the autonomous fixer is a separate ticket.
+ */
+__exportStar(require("./types"), exports);
+__exportStar(require("./conformance"), exports);
+__exportStar(require("./observer"), exports);

package/dist/lib/plumber/observer.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Plumber — observer (TICKET-216, observer half).
+ *
+ * READ-MOSTLY: turns a KSL record (+ optional Position-Map context) into a routed
+ * PlumberObservation. It NEVER writes code — only classifies and emits to sinks
+ * (failure substrate, skill-candidate queue, plumber.alert events). The autonomous
+ * fixer is a separate, gated ticket.
+ *
+ * `classify()` is pure + synchronous (easy to test). `observe()` adds the optional
+ * async LLM flagger + routes the observation to sinks.
+ *
+ * Zero-dep: stdlib + in-core modules (KSL types, event-bus, code-failure-logger).
+ */
+import type { KSLRecord } from '../ksl/record-writer';
+import type { CodeFailureEntry } from '../code-failure-logger';
+import { type ConformanceResult, type PositionMapContext, type PlumberObservation, type PlumberSinks } from './types';
+import { type ConformanceRuleset, type LlmConformanceFlagger } from './conformance';
+export interface ObserveOptions {
+    ruleset?: ConformanceRuleset;
+    sinks?: PlumberSinks;
+    flagger?: LlmConformanceFlagger;
+    now?: string;
+}
+/**
+ * Pure classification — no side effects. Given a record (+ optional pre-computed
+ * conformance results) returns the observation. Verdict logic:
+ *   - any high-severity non-conformance → failure (position_map_violation if a wedge
+ *     dimension is implicated, else sop_nonconformance)
+ *   - else execution errors present → failure (execution_error)
+ *   - else any warn-level non-conformance → anomaly (signal_mismatch if signal was high)
+ *   - else signal_strength 'high' → success_pattern (skill candidate)
+ *   - else → conformant
+ */
+export declare function classify(record: KSLRecord, ctx?: PositionMapContext, conformance?: ConformanceResult[], now?: string): PlumberObservation;
+/** Observe one record: classify (+ optional async flagger) and route to sinks. */
+export declare function observe(record: KSLRecord, ctx?: PositionMapContext, opts?: ObserveOptions): Promise<PlumberObservation>;
+/** Observe a batch of records sequentially (stable sink ordering). */
+export declare function observeBatch(records: KSLRecord[], ctxFor?: (r: KSLRecord) => PositionMapContext | undefined, opts?: ObserveOptions): Promise<PlumberObservation[]>;
+/**
+ * Default sinks: every observation emits an `interrupt.plumber.alert` event tagged
+ * by kind. Pass `overrides` to wire richer destinations — e.g. route failures to
+ * `logCodeFailure(toCodeFailureEntry(obs, record))`, or skill candidates to the
+ * skill-crystalliser (which lives outside core). Defaults stay zero-dep.
+ */
+export declare function defaultPlumberSinks(overrides?: Partial<PlumberSinks>): PlumberSinks;
+/**
+ * Map a Plumber failure observation onto the code-failure-logger schema, for
+ * callers that want failures to land in the existing failure library:
+ *   import { logCodeFailure } from '@kognai/orchestrator-core';
+ *   sinks.onFailure = (obs, rec) => logCodeFailure(toCodeFailureEntry(obs, rec));
+ */
+export declare function toCodeFailureEntry(obs: PlumberObservation, record: KSLRecord): CodeFailureEntry;

package/dist/lib/plumber/observer.js

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * Plumber — observer (TICKET-216, observer half).
+ *
+ * READ-MOSTLY: turns a KSL record (+ optional Position-Map context) into a routed
+ * PlumberObservation. It NEVER writes code — only classifies and emits to sinks
+ * (failure substrate, skill-candidate queue, plumber.alert events). The autonomous
+ * fixer is a separate, gated ticket.
+ *
+ * `classify()` is pure + synchronous (easy to test). `observe()` adds the optional
+ * async LLM flagger + routes the observation to sinks.
+ *
+ * Zero-dep: stdlib + in-core modules (KSL types, event-bus, code-failure-logger).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classify = classify;
+exports.observe = observe;
+exports.observeBatch = observeBatch;
+exports.defaultPlumberSinks = defaultPlumberSinks;
+exports.toCodeFailureEntry = toCodeFailureEntry;
+const event_bus_publisher_1 = require("../event-bus-publisher");
+const types_1 = require("./types");
+const conformance_1 = require("./conformance");
+const DIM_PRIORITY = ['security', 'sovereignty', 'intelligence', 'memory'];
+function dominantDimension(results) {
+    for (const d of DIM_PRIORITY) {
+        if (results.some(r => r.dimension === d))
+            return d;
+    }
+    return 'none';
+}
+/**
+ * Pure classification — no side effects. Given a record (+ optional pre-computed
+ * conformance results) returns the observation. Verdict logic:
+ *   - any high-severity non-conformance → failure (position_map_violation if a wedge
+ *     dimension is implicated, else sop_nonconformance)
+ *   - else execution errors present → failure (execution_error)
+ *   - else any warn-level non-conformance → anomaly (signal_mismatch if signal was high)
+ *   - else signal_strength 'high' → success_pattern (skill candidate)
+ *   - else → conformant
+ */
+function classify(record, ctx, conformance, now) {
+    const results = conformance ?? (0, conformance_1.runConformance)(record, ctx);
+    const failures = results.filter(c => !c.ok);
+    const high = failures.filter(c => c.severity === 'high');
+    const hasErrors = (record.errors?.length ?? 0) > 0;
+    let verdict;
+    let failureType;
+    let severity = 'info';
+    let dimension = 'none';
+    if (high.length > 0) {
+        verdict = 'failure';
+        severity = 'high';
+        dimension = dominantDimension(high);
+        // A position_map_violation = a high failure on a check that consulted the
+        // agent's Position-Map context (it contradicted its own declared position).
+        // A high failure that merely touches a wedge dimension (e.g. KSL completeness)
+        // is generic sop_nonconformance.
+        failureType = high.some(c => c.positionRelative) ? 'position_map_violation' : 'sop_nonconformance';
+    }
+    else if (hasErrors) {
+        verdict = 'failure';
+        severity = 'high';
+        failureType = 'execution_error';
+    }
+    else if (failures.length > 0) {
+        verdict = 'anomaly';
+        severity = 'warn';
+        dimension = dominantDimension(failures);
+        if (record.signal_strength === 'high')
+            failureType = 'signal_mismatch';
+    }
+    else if (record.signal_strength === 'high') {
+        verdict = 'success_pattern';
+    }
+    else {
+        verdict = 'conformant';
+    }
+    const failed = failures.map(c => c.message);
+    const summary = verdict === 'failure' ? `${failureType}: ${failed.join('; ') || 'execution errors'}`
+        : verdict === 'anomaly' ? `anomaly: ${failed.join('; ')}`
+            : verdict === 'success_pattern' ? `high-signal clean attempt (skill candidate)`
+                : 'conformant';
+    return {
+        ref: (0, types_1.refOf)(record),
+        verdict,
+        conformance: results,
+        failureType,
+        dimension: dimension !== 'none' ? dimension : undefined,
+        severity,
+        signal_strength: record.signal_strength,
+        summary,
+        observed_at: now ?? new Date().toISOString(),
+    };
+}
+/** Observe one record: classify (+ optional async flagger) and route to sinks. */
+async function observe(record, ctx, opts = {}) {
+    const ruleset = opts.ruleset ?? conformance_1.DEFAULT_RULESET;
+    const sinks = opts.sinks ?? defaultPlumberSinks();
+    let conformance = (0, conformance_1.runConformance)(record, ctx, ruleset);
+    if (opts.flagger) {
+        try {
+            conformance = conformance.concat(await opts.flagger.flag(record, ctx));
+        }
+        catch { /* advisory flagger must never break observation */ }
+    }
+    const obs = classify(record, ctx, conformance, opts.now);
+    try {
+        if (obs.verdict === 'failure')
+            await sinks.onFailure(obs, record, ctx);
+        else if (obs.verdict === 'success_pattern')
+            await sinks.onSkillCandidate(obs, record, ctx);
+        else if (obs.verdict === 'anomaly')
+            await sinks.onAlert(obs, record, ctx);
+        // conformant → no routing
+    }
+    catch { /* sinks must never break the observer */ }
+    return obs;
+}
+/** Observe a batch of records sequentially (stable sink ordering). */
+async function observeBatch(records, ctxFor, opts = {}) {
+    const out = [];
+    for (const r of records)
+        out.push(await observe(r, ctxFor?.(r), opts));
+    return out;
+}
+// ── Default sinks — emit plumber.alert interrupt events (zero new deps) ───────
+function buildPlumberAlert(obs, record, ctx, kind) {
+    return {
+        event_type: 'interrupt.plumber.alert',
+        agent_id: record.agent,
+        sprint: record.sprint_id,
+        timestamp: obs.observed_at,
+        payload: {
+            kind,
+            verdict: obs.verdict,
+            failure_type: obs.failureType ?? null,
+            dimension: obs.dimension ?? null,
+            severity: obs.severity,
+            task_id: obs.ref.task_id,
+            attempt: obs.ref.attempt,
+            summary: obs.summary,
+            failed_checks: obs.conformance.filter(c => !c.ok).map(c => c.checkId),
+            position: ctx ? { layer: ctx.layer ?? null, profile: ctx.optimizationProfile ?? null, namespace: ctx.namespace ?? null } : null,
+        },
+    };
+}
+/**
+ * Default sinks: every observation emits an `interrupt.plumber.alert` event tagged
+ * by kind. Pass `overrides` to wire richer destinations — e.g. route failures to
+ * `logCodeFailure(toCodeFailureEntry(obs, record))`, or skill candidates to the
+ * skill-crystalliser (which lives outside core). Defaults stay zero-dep.
+ */
+function defaultPlumberSinks(overrides = {}) {
+    const emit = (obs, r, c, kind) => (0, event_bus_publisher_1.publishEvent)(buildPlumberAlert(obs, r, c, kind));
+    return {
+        onFailure: overrides.onFailure ?? ((o, r, c) => emit(o, r, c, 'failure')),
+        onSkillCandidate: overrides.onSkillCandidate ?? ((o, r, c) => emit(o, r, c, 'skill_candidate')),
+        onAlert: overrides.onAlert ?? ((o, r, c) => emit(o, r, c, 'anomaly')),
+    };
+}
+/**
+ * Map a Plumber failure observation onto the code-failure-logger schema, for
+ * callers that want failures to land in the existing failure library:
+ *   import { logCodeFailure } from '@kognai/orchestrator-core';
+ *   sinks.onFailure = (obs, rec) => logCodeFailure(toCodeFailureEntry(obs, rec));
+ */
+function toCodeFailureEntry(obs, record) {
+    return {
+        taskId: record.task_id,
+        sprintId: record.sprint_id,
+        agentId: record.agent,
+        attemptNum: record.attempt,
+        score: record.constitutional_score ?? 0,
+        model: record.candidate_id || 'unknown',
+        rejectionReason: obs.summary,
+        issues: obs.conformance.filter(c => !c.ok).map(c => ({ severity: c.severity, file: '', description: c.message })),
+        failType: 'supervisor_rejected',
+    };
+}