@kognai/orchestrator-core 0.1.0

package/dist/lib/event-bus-publisher.js

@@ -0,0 +1,188 @@
+"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 __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.publishEvent = publishEvent;
+exports.publishTaskStarted = publishTaskStarted;
+exports.publishTaskCompleted = publishTaskCompleted;
+exports.publishTaskFailed = publishTaskFailed;
+exports.publishBudgetWarning = publishBudgetWarning;
+exports.publishBudgetFreeze = publishBudgetFreeze;
+exports.publishSprintStarted = publishSprintStarted;
+exports.publishSprintCompleted = publishSprintCompleted;
+exports.publishAchiriChat = publishAchiriChat;
+exports.publishAchiriVoice = publishAchiriVoice;
+// TICKET-215 Phase 3b-3 Wave B: moved into @kognai/orchestrator-core verbatim.
+// Publishes events to Supabase via raw HTTPS REST (NOT @supabase/supabase-js) —
+// no path coupling, no external deps. Reads SUPABASE_URL/SERVICE_KEY from env;
+// graceful no-op (events dropped) if unset.
+const https = __importStar(require("https"));
+// Config — reads from process.env; graceful no-op if missing
+const SUPABASE_URL = process.env.SUPABASE_URL || '';
+const SUPABASE_SERVICE_KEY = process.env.SUPABASE_SERVICE_KEY || '';
+let _warnedMissing = false;
+function checkConfig() {
+    if (!SUPABASE_URL || !SUPABASE_SERVICE_KEY) {
+        if (!_warnedMissing) {
+            process.stderr.write('[event-bus] SUPABASE_URL or SUPABASE_SERVICE_KEY not set — events will be dropped\n');
+            _warnedMissing = true;
+        }
+        return false;
+    }
+    return true;
+}
+async function publishEvent(event) {
+    if (!checkConfig())
+        return;
+    return new Promise((resolve) => {
+        const body = JSON.stringify(event);
+        const url = new URL(`${SUPABASE_URL}/rest/v1/kognai_events`);
+        const req = https.request({
+            hostname: url.hostname,
+            port: url.port || 443,
+            path: url.pathname,
+            method: 'POST',
+            headers: {
+                'apikey': SUPABASE_SERVICE_KEY,
+                'Authorization': `Bearer ${SUPABASE_SERVICE_KEY}`,
+                'Content-Type': 'application/json',
+                'Prefer': 'return=minimal',
+                'Content-Length': Buffer.byteLength(body),
+            },
+            timeout: 5000,
+        }, () => resolve());
+        req.on('error', () => resolve());
+        req.on('timeout', () => { req.destroy(); resolve(); });
+        req.write(body);
+        req.end();
+    });
+}
+function publishTaskStarted(agentId, sprint, taskId, title) {
+    return publishEvent({
+        event_type: 'task.started',
+        agent_id: agentId,
+        sprint,
+        timestamp: new Date().toISOString(),
+        payload: { task_id: taskId, title, status: 'started' },
+    });
+}
+function publishTaskCompleted(agentId, sprint, taskId, title, costUsdc) {
+    return publishEvent({
+        event_type: 'task.completed',
+        agent_id: agentId,
+        sprint,
+        timestamp: new Date().toISOString(),
+        payload: { task_id: taskId, title, status: 'completed', costUsdc },
+    });
+}
+function publishTaskFailed(agentId, sprint, taskId, title, reason) {
+    return publishEvent({
+        event_type: 'task.failed',
+        agent_id: agentId,
+        sprint,
+        timestamp: new Date().toISOString(),
+        payload: { task_id: taskId, title, status: 'failed', reason },
+    });
+}
+function publishBudgetWarning(sprint, burnPct, spentUsdc, budgetUsdc) {
+    return publishEvent({
+        event_type: 'interrupt.budget.warning',
+        agent_id: 'bloomberg',
+        sprint,
+        timestamp: new Date().toISOString(),
+        payload: { burnPct, spentUsdc, budgetUsdc },
+    });
+}
+function publishBudgetFreeze(sprint, burnPct) {
+    return publishEvent({
+        event_type: 'interrupt.budget.freeze',
+        agent_id: 'bloomberg',
+        sprint,
+        timestamp: new Date().toISOString(),
+        payload: { burnPct, spentUsdc: 0, budgetUsdc: 0 },
+    });
+}
+function publishSprintStarted(sprint, taskCount) {
+    return publishEvent({
+        event_type: 'system.sprint.started',
+        agent_id: 'orchestrator',
+        sprint,
+        timestamp: new Date().toISOString(),
+        payload: { sprint, taskCount, completedCount: 0 },
+    });
+}
+function publishSprintCompleted(sprint, taskCount, completedCount) {
+    return publishEvent({
+        event_type: 'system.sprint.completed',
+        agent_id: 'orchestrator',
+        sprint,
+        timestamp: new Date().toISOString(),
+        payload: { sprint, taskCount, completedCount },
+    });
+}
+// Sprint 643: Achiri alpha monitoring
+function publishAchiriChat(opts) {
+    return publishEvent({
+        event_type: 'achiri.chat',
+        agent_id: 'achiri',
+        sprint: 'alpha',
+        timestamp: new Date().toISOString(),
+        payload: {
+            user_id: opts.userId,
+            tier: opts.tier,
+            model: opts.model,
+            provider: opts.provider,
+            message_length: opts.messageLength,
+            response_time_ms: opts.responseTimeMs,
+            turns_in_memory: opts.turnsInMemory,
+        },
+    });
+}
+function publishAchiriVoice(opts) {
+    return publishEvent({
+        event_type: 'achiri.voice',
+        agent_id: 'achiri',
+        sprint: 'alpha',
+        timestamp: new Date().toISOString(),
+        payload: {
+            user_id: opts.userId,
+            tier: opts.tier,
+            model: opts.model,
+            provider: opts.provider,
+            message_length: 0,
+            response_time_ms: opts.responseTimeMs,
+            turns_in_memory: 0,
+        },
+    });
+}

package/dist/lib/event-bus-types.d.ts

@@ -0,0 +1,73 @@
+export type TaskEventType = 'task.queued' | 'task.started' | 'task.completed' | 'task.failed' | 'task.rejected';
+export type AgentEventType = 'agent.available' | 'agent.busy' | 'agent.degraded';
+export type DataEventType = 'data.research.complete' | 'data.frame.extracted' | 'data.caption.generated' | 'data.citizen_score';
+export type InterruptEventType = 'interrupt.plumber.alert' | 'interrupt.budget.warning' | 'interrupt.budget.freeze';
+export type SystemEventType = 'system.sprint.started' | 'system.sprint.completed' | 'system.heartbeat';
+export type AchiriEventType = 'achiri.chat' | 'achiri.voice' | 'achiri.onboard';
+export interface AchiriEventPayload {
+    user_id: string;
+    tier: string;
+    model: string;
+    provider: string;
+    message_length: number;
+    response_time_ms: number;
+    turns_in_memory: number;
+    [key: string]: unknown;
+}
+export type KognaiEventType = TaskEventType | AgentEventType | DataEventType | InterruptEventType | SystemEventType | AchiriEventType;
+export interface TaskEventPayload {
+    task_id: string;
+    title: string;
+    status: string;
+    costUsdc?: number;
+    reason?: string;
+    [key: string]: unknown;
+}
+export interface BudgetEventPayload {
+    burnPct: number;
+    spentUsdc: number;
+    budgetUsdc: number;
+    [key: string]: unknown;
+}
+export interface SprintEventPayload {
+    sprint: string;
+    taskCount: number;
+    completedCount: number;
+    [key: string]: unknown;
+}
+export interface BaseEvent {
+    event_type: KognaiEventType;
+    agent_id: string;
+    sprint: string;
+    timestamp: string;
+    payload: Record<string, unknown>;
+    inserted_at?: string;
+}
+export interface TaskEvent extends BaseEvent {
+    event_type: TaskEventType;
+    payload: TaskEventPayload;
+}
+export interface AgentEvent extends BaseEvent {
+    event_type: AgentEventType;
+    payload: Record<string, unknown>;
+}
+export interface DataEvent extends BaseEvent {
+    event_type: DataEventType;
+    payload: Record<string, unknown>;
+}
+export interface InterruptEvent extends BaseEvent {
+    event_type: InterruptEventType;
+    payload: BudgetEventPayload | Record<string, unknown>;
+}
+export interface SystemEvent extends BaseEvent {
+    event_type: SystemEventType;
+    payload: SprintEventPayload | Record<string, unknown>;
+}
+export interface AchiriEvent extends BaseEvent {
+    event_type: AchiriEventType;
+    payload: AchiriEventPayload;
+}
+export type KognaiEvent = TaskEvent | AgentEvent | DataEvent | InterruptEvent | SystemEvent | AchiriEvent;
+export declare function isTaskEvent(e: KognaiEvent): e is TaskEvent;
+export declare function isInterruptEvent(e: KognaiEvent): e is InterruptEvent;
+export declare function isSystemEvent(e: KognaiEvent): e is SystemEvent;

package/dist/lib/event-bus-types.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTaskEvent = isTaskEvent;
+exports.isInterruptEvent = isInterruptEvent;
+exports.isSystemEvent = isSystemEvent;
+// Type guard functions
+function isTaskEvent(e) {
+    return (e.event_type === 'task.queued' ||
+        e.event_type === 'task.started' ||
+        e.event_type === 'task.completed' ||
+        e.event_type === 'task.failed' ||
+        e.event_type === 'task.rejected');
+}
+function isInterruptEvent(e) {
+    return (e.event_type === 'interrupt.plumber.alert' ||
+        e.event_type === 'interrupt.budget.warning' ||
+        e.event_type === 'interrupt.budget.freeze');
+}
+function isSystemEvent(e) {
+    return (e.event_type === 'system.sprint.started' ||
+        e.event_type === 'system.sprint.completed' ||
+        e.event_type === 'system.heartbeat');
+}

package/dist/lib/failure-library.d.ts

@@ -0,0 +1,178 @@
+/**
+ * Failure Library Consumer — TICKET-152 Gap 2.
+ *
+ * `code-failure-logger.ts` WRITES rejection records to
+ * `<root>/data/failure-library/code/fail-*.json`. Until now nothing READ them
+ * back, so a task could be rejected for the same reason on every attempt and the
+ * agent never saw its own history — e.g. `ksl_batch_runner` accumulated 75 failure
+ * records and still never converged. This module closes that loop.
+ *
+ * Three surfaces:
+ *   1. aggregateCodeFailures()  — collapse the raw log into per-task summaries
+ *                                 (how deep it stuck, what kind of failure, the
+ *                                 recurring theme). The analytics view.
+ *   2. promoteLessons()         — write a human/agent-readable LESSONS.md to the
+ *                                 failure-library root. The promotion view; this
+ *                                 is the `learnings_ref` decomposer-feedback points at.
+ *   3. retrieveTaskFailures()   — retry-aware retrieval for ONE task: a compact
+ *                                 "here is what your last N attempts were rejected
+ *                                 for, do not repeat it" brief, ready to inject
+ *                                 into the next attempt's prompt. The feedback view.
+ *
+ * Stdlib only: fs, path. Read failures degrade to empty results — a missing or
+ * corrupt library must never throw into a running sprint.
+ */
+/** Raw on-disk shape written by code-failure-logger.ts. */
+export interface RawCodeFailure {
+    entry_id: string;
+    task_id: string;
+    sprint_id: string;
+    agent_id: string;
+    attempt_num: number;
+    score: number;
+    model: string;
+    fail_type: string;
+    rejection_reason: string;
+    issues: Array<{
+        severity: string;
+        file: string;
+        description: string;
+    }>;
+    filed_at: string;
+}
+export interface TaskFailureSummary {
+    task_id: string;
+    total_failures: number;
+    /** Highest attempt_num seen — how many retries the task burned before giving up. */
+    max_attempt: number;
+    /** failType -> count. */
+    fail_types: Record<string, number>;
+    /** model -> count. */
+    models: Record<string, number>;
+    /** Coarse failure signature -> count (the actionable "recurring theme"). */
+    signatures: Record<string, number>;
+    sprint_ids: string[];
+    latest_score: number;
+    latest_reason: string;
+    latest_filed_at: string;
+    /** total_failures >= recurringThreshold — same task rejected over and over. */
+    recurring: boolean;
+    /** Exhausted retries without converging (deep attempt or chronic volume). */
+    no_converge: boolean;
+}
+export interface AggregateThresholds {
+    /** A task with >= this many total records is "recurring". */
+    recurring: number;
+    /** A task whose max_attempt >= this, OR total >= noConvergeVolume, never converged. */
+    noConvergeAttempt: number;
+    noConvergeVolume: number;
+}
+export declare const DEFAULT_THRESHOLDS: AggregateThresholds;
+/**
+ * Common base both failure schemas project onto — TICKET-152 Gap 3, Option A.
+ * Contract: contracts/common/failure-entry-base-v1.json. The base itself is just
+ * {entry_id, filed_at} (the literal subset both schemas already carry, so the
+ * SCS-001 lock is preserved); the richer fields are the projection layer that
+ * lets one consumer read code-failure and SCS-001 records through one shape.
+ */
+export interface FailureEntryBase {
+    entry_id: string;
+    filed_at: string;
+    subject_ref: string;
+    failure_class: string;
+    score: number | null;
+    filed_by: string;
+}
+/** Project a raw code-failure record onto FailureEntryBase (see contract conformance). */
+export declare function projectCodeFailureToBase(e: RawCodeFailure): FailureEntryBase;
+/**
+ * Read every fail-*.json under data/failure-library/code/. Corrupt or partial
+ * files are skipped, never thrown — the writer and readers run concurrently, so a
+ * half-written file is expected and must not break a read.
+ */
+export declare function readAllCodeFailures(root?: string): RawCodeFailure[];
+/**
+ * Reduce a rejection to a coarse, deterministic signature so recurring themes
+ * surface across attempts. No LLM — keyword heuristics over the reason + issues.
+ */
+export declare function failureSignature(entry: RawCodeFailure): string;
+/**
+ * Collapse the raw log into one summary per task_id, sorted most-failed first.
+ */
+export declare function aggregateCodeFailures(root?: string, thresholds?: AggregateThresholds): TaskFailureSummary[];
+export interface RetrievalOptions {
+    root?: string;
+    /** Cap how many prior attempts go into the brief (most recent first). */
+    maxAttempts?: number;
+    /** Truncate each rejection reason to keep the prompt budget bounded. */
+    maxReasonChars?: number;
+    /** Cap issue bullets carried per attempt. */
+    maxIssuesPerAttempt?: number;
+}
+export interface RetrievalResult {
+    task_id: string;
+    prior_attempts: number;
+    entries: RawCodeFailure[];
+    /** Recurring theme(s) across this task's failures, most frequent first. */
+    themes: string[];
+    /** Formatted block ready to prepend to a retry prompt; '' when no history. */
+    brief: string;
+}
+/**
+ * Retrieve everything the library knows about ONE task and synthesize a compact
+ * avoidance brief. This is the piece that was missing: call it before re-running a
+ * rejected task and prepend `.brief` to the agent's prompt so attempt N+1 can see
+ * why attempts 1..N were rejected.
+ */
+export declare function retrieveTaskFailures(taskId: string, opts?: RetrievalOptions): RetrievalResult;
+export interface AgentRetrievalOptions {
+    root?: string;
+    /** Look-back window in days (default 14). */
+    sinceDays?: number;
+    /** Cap entries carried in the result, most recent first. */
+    maxEntries?: number;
+}
+export interface AgentFailureWindow {
+    agent_id: string;
+    window_days: number;
+    total: number;
+    /** Failure signature -> count, most frequent first when read as entries. */
+    by_signature: Record<string, number>;
+    by_task: Array<{
+        task_id: string;
+        count: number;
+    }>;
+    /** The most frequent theme — where this agent should focus improvement. */
+    weakest_signature: string;
+    entries: RawCodeFailure[];
+    /** Improve-mode summary, ready to hand an agent reviewing its own log. */
+    brief: string;
+}
+/**
+ * "Failures attributed to agent_id X over the last N days." Powers SOP-GEN-013
+ * Improve-mode and the per-agent AIC curve in TICKET-110. `nowISO` is injected
+ * (callers pass new Date().toISOString()) to keep this deterministic/testable.
+ */
+export declare function retrieveAgentFailures(agentId: string, nowISO: string, opts?: AgentRetrievalOptions): AgentFailureWindow;
+export interface PromoteOptions {
+    root?: string;
+    thresholds?: AggregateThresholds;
+    /** Only promote tasks that are recurring or non-converging (default true). */
+    recurringOnly?: boolean;
+}
+/**
+ * Render LESSONS.md content from the aggregate. Pure (no I/O) so it's testable.
+ */
+export declare function renderLessons(summaries: TaskFailureSummary[], generatedAt: string): string;
+export interface PromoteResult {
+    path: string;
+    promoted: number;
+    totalTasks: number;
+    content: string;
+}
+/**
+ * Build the aggregate and write LESSONS.md to the failure-library root.
+ * `generatedAt` is injected (callers pass new Date().toISOString()) so this stays
+ * deterministic and testable.
+ */
+export declare function promoteLessons(generatedAt: string, opts?: PromoteOptions): PromoteResult;