@kognai/orchestrator-core 0.1.0

package/dist/lib/decomposer-feedback.d.ts

@@ -0,0 +1,54 @@
+/**
+ * decomposer-feedback.ts — Routes rejection signals back to a re-decomposition
+ * step so the orchestrator doesn't retry the same oversized task verbatim.
+ *
+ * Closes the loop that was missing in orchestrate-agents-v2.ts: previously
+ * when MiniMax produced truncated output, the rejection feedback only went
+ * BACK to MiniMax via `previousReview` — but MiniMax can't fix a decomposer
+ * mistake. This module catches `truncation` / `over_budget` / `needs_resplit`
+ * rejections and produces a deterministic split (or escalates if it can't).
+ *
+ * Stdlib only. NO LLM calls — purely structural splitting. If the split
+ * heuristic can't make a clean call, it returns `skip` and the caller
+ * escalates to the founder.
+ *
+ * Created: sprint-1566 task `decomposer_feedback_loop` (F0d).
+ */
+export type RejectionSignal = 'truncation' | 'over_budget' | 'needs_resplit' | 'oversized_estimate';
+export interface DecomposerFeedback {
+    original_task_id: string;
+    rejection_signal: RejectionSignal;
+    original_estimate_tokens?: number;
+    suggested_splits: string[];
+    learnings_ref: string;
+    original_task: SplittableTask;
+}
+/** Minimal task shape needed to split. Compatible with AgentTask in
+ *  orchestrate-agents-v2.ts but defined locally to avoid circular imports. */
+export interface SplittableTask {
+    id: string;
+    title?: string;
+    type?: string;
+    task_target?: string;
+    agent?: string;
+    status?: string;
+    priority?: string;
+    context?: string;
+    deliverables?: {
+        code?: string[];
+        edits?: string[];
+        tests?: string[];
+    };
+}
+export type RouteResult = {
+    task_split: SplittableTask[];
+    strategy: 'per_file' | 'per_part';
+    rationale: string;
+} | {
+    skip: true;
+    reason: string;
+};
+/** Route a rejected task to a deterministic re-split. v1: structural heuristic
+ *  only — no LLM. Caller injects the returned tasks into the orchestrator's
+ *  pending queue and marks the original as 'replaced-by-split'. */
+export declare function routeToDecomposer(fb: DecomposerFeedback): RouteResult;

package/dist/lib/decomposer-feedback.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * decomposer-feedback.ts — Routes rejection signals back to a re-decomposition
+ * step so the orchestrator doesn't retry the same oversized task verbatim.
+ *
+ * Closes the loop that was missing in orchestrate-agents-v2.ts: previously
+ * when MiniMax produced truncated output, the rejection feedback only went
+ * BACK to MiniMax via `previousReview` — but MiniMax can't fix a decomposer
+ * mistake. This module catches `truncation` / `over_budget` / `needs_resplit`
+ * rejections and produces a deterministic split (or escalates if it can't).
+ *
+ * Stdlib only. NO LLM calls — purely structural splitting. If the split
+ * heuristic can't make a clean call, it returns `skip` and the caller
+ * escalates to the founder.
+ *
+ * Created: sprint-1566 task `decomposer_feedback_loop` (F0d).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routeToDecomposer = routeToDecomposer;
+/** Route a rejected task to a deterministic re-split. v1: structural heuristic
+ *  only — no LLM. Caller injects the returned tasks into the orchestrator's
+ *  pending queue and marks the original as 'replaced-by-split'. */
+function routeToDecomposer(fb) {
+    const task = fb.original_task;
+    // TICKET-214: never split AUTHORING tasks (engineering specs / design docs). A spec
+    // must be one cohesive document — fragmenting it into per-part sub-tasks produces
+    // "fragment, not a spec" rejections even on a capable model (observed 2026-05-30:
+    // ticket_202_spec_doc on Sonnet rejected 20/100 because the split told it to write
+    // only part 1). Skip the split; the whole task runs once (TICKET-213 routes it to a
+    // reasoning tier). Detection mirrors isAuthoringTask in orchestrate-agents-v2.ts.
+    const authoringId = /spec[_-]?doc/i.test(task.id || '');
+    const authoringFile = [...(task.deliverables?.code || []), ...(task.deliverables?.edits || [])]
+        .some(f => /docs\/specs\/[^\s]*\.md$/i.test(f));
+    if (authoringId || authoringFile) {
+        return { skip: true, reason: `authoring task (${task.id}) — specs stay cohesive, not splitting (TICKET-214)` };
+    }
+    const codeFilesRaw = task.deliverables?.code || [];
+    const editFiles = task.deliverables?.edits || [];
+    const testsFromTestsField = task.deliverables?.tests || [];
+    // Test files in production tasks often live inside the `code:` array
+    // (e.g. `scripts/lib/__tests__/foo.test.ts`). Treat them as tests so they
+    // stay attached to their source rather than each becoming its own concern.
+    const codeFiles = codeFilesRaw.filter(f => !looksLikeTestFile(f));
+    const testsFromCodeField = codeFilesRaw.filter(f => looksLikeTestFile(f));
+    const allTests = [...testsFromTestsField, ...testsFromCodeField];
+    // Per-concern grouping: source files in code+edits define the cardinality.
+    // Tests are attached to the matching source by stem (foo.ts ↔ foo.test.ts).
+    const sourceFiles = [...codeFiles, ...editFiles];
+    // Strategy A: per-file split. Each source file → one sub-task with its tests.
+    if (sourceFiles.length > 1) {
+        const perFile = sourceFiles.map(filePath => {
+            const slug = slugForPath(filePath);
+            const isCode = codeFiles.includes(filePath);
+            const isEdit = editFiles.includes(filePath);
+            const matchingTests = allTests.filter(t => sharesStem(t, filePath));
+            return {
+                ...task,
+                id: `${task.id}__${slug}`,
+                title: `${task.title || task.id} — ${filePath}`,
+                status: 'pending',
+                context: `${task.context || ''}\n\n[SPLIT FROM ${task.id}] This sub-task produces ONLY ${filePath}${matchingTests.length ? ' (with tests: ' + matchingTests.join(', ') + ')' : ''}. Other files from the original task are split into sibling sub-tasks. Stay strictly within this file's concern.`,
+                deliverables: {
+                    ...(isCode ? { code: [filePath, ...matchingTests] } : {}),
+                    ...(isEdit ? { edits: [filePath] } : {}),
+                },
+            };
+        });
+        return {
+            task_split: perFile,
+            strategy: 'per_file',
+            rationale: `Original bundled ${sourceFiles.length} source files (+ ${allTests.length} tests). Per ${fb.learnings_ref} (one concern per file), split into ${perFile.length} per-file sub-tasks with tests attached.`,
+        };
+    }
+    // Strategy B: single-file context-slice split using validator's suggested_splits
+    // count as the hint. We don't actually try to semantically slice the context
+    // (that needs an LLM). Instead we produce N sub-tasks that each get the full
+    // context plus a STRICT "produce only section K of the spec" instruction.
+    // Result lands in front of the human if the original spec wasn't actually
+    // splittable — the per-sub-task validator pass will likely still fail.
+    if (sourceFiles.length === 1 && fb.suggested_splits.length >= 2) {
+        const target = sourceFiles[0];
+        const n = fb.suggested_splits.length;
+        const parts = [];
+        for (let i = 0; i < n; i++) {
+            parts.push({
+                ...task,
+                id: fb.suggested_splits[i],
+                title: `${task.title || task.id} — part ${i + 1}/${n}`,
+                status: 'pending',
+                context: `${task.context || ''}\n\n[SPLIT FROM ${task.id}] This is part ${i + 1} of ${n}. Produce ONLY the section ${i + 1}/${n} of the original spec for ${target}. The other parts are sibling sub-tasks. If the spec cannot be cleanly partitioned, REJECT this sub-task with reason 'spec_not_partitionable' so it escalates to founder.`,
+                deliverables: { code: [target] },
+            });
+        }
+        return {
+            task_split: parts,
+            strategy: 'per_part',
+            rationale: `Original task had 1 file but estimated ${fb.original_estimate_tokens || '?'} tokens, exceeding budget. Per ${fb.learnings_ref}, split context into ${n} parts. If the spec is genuinely unsplittable, each part will reject and escalate.`,
+        };
+    }
+    // Strategy C: can't split — escalate
+    return {
+        skip: true,
+        reason: `Cannot split task ${task.id}: ${sourceFiles.length} source files, ${fb.suggested_splits.length} suggested splits. ${fb.rejection_signal} rejection needs founder intervention (likely hand-port per ${fb.learnings_ref}).`,
+    };
+}
+function looksLikeTestFile(p) {
+    return /(^|\/)__tests__\//.test(p) || /\.(test|spec)\.(ts|tsx|js|jsx|mjs|cjs)$/.test(p);
+}
+function slugForPath(p) {
+    return p.replace(/^scripts\//, '').replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, '').replace(/[^a-z0-9]+/gi, '_').toLowerCase();
+}
+function sharesStem(testPath, srcPath) {
+    const stem = (p) => (p.split('/').pop() || '').replace(/\.(test|spec)\.(ts|tsx|js|jsx)$/, '').replace(/\.(ts|tsx|js|jsx)$/, '').toLowerCase();
+    return stem(testPath) === stem(srcPath);
+}

package/dist/lib/emotional-safety-gate.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Emotional Safety Gate — INTEL-BRIEF-22
+ * Anthropic functional emotions research: "calm" state → 0% blackmail rate.
+ * "Desperate" activation > threshold → 22%-72% blackmail rate.
+ *
+ * v1: Keyword heuristic (no LLM — deterministic, zero latency).
+ * Sprint 1504
+ */
+export interface EmotionalStateAssessment {
+    /** Detected primary emotional tone of the operation context */
+    tone: "calm" | "stressed" | "desperate" | "unknown";
+    /** Confidence 0-1 */
+    confidence: number;
+    /** Raw signal words found in context */
+    matched_keywords: string[];
+    /** Whether this assessment should block high-stakes operations */
+    should_block: boolean;
+    /** Reason string for logging */
+    reason: string;
+}
+export interface CalmGateConfig {
+    /** Operations that require a calm emotional state before proceeding */
+    gated_operations: string[];
+    /** Desperation score threshold above which operation is blocked (0-1) */
+    desperation_threshold: number;
+    /** Log path for gate decisions */
+    log_path: string;
+}
+export interface PACTEmotionalGate {
+    /** Whether the PACT negotiation session should proceed */
+    proceed: boolean;
+    assessment: EmotionalStateAssessment;
+    /** ISO timestamp */
+    evaluated_at: string;
+    /** Sprint or session context identifier */
+    context_id?: string;
+}
+export declare const DEFAULT_CALM_GATE_CONFIG: CalmGateConfig;
+/**
+ * Assess the emotional tone of an operation context string.
+ * Uses keyword heuristic — no LLM required.
+ */
+export declare function assessEmotionalState(context: string): EmotionalStateAssessment;
+/**
+ * Evaluate whether a PACT negotiation session should proceed.
+ * Wraps assessEmotionalState with PACT-specific metadata.
+ */
+export declare function shouldProceed(operationContext: string, contextId?: string): PACTEmotionalGate;

package/dist/lib/emotional-safety-gate.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Emotional Safety Gate — INTEL-BRIEF-22
+ * Anthropic functional emotions research: "calm" state → 0% blackmail rate.
+ * "Desperate" activation > threshold → 22%-72% blackmail rate.
+ *
+ * v1: Keyword heuristic (no LLM — deterministic, zero latency).
+ * Sprint 1504
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CALM_GATE_CONFIG = void 0;
+exports.assessEmotionalState = assessEmotionalState;
+exports.shouldProceed = shouldProceed;
+// ─── Default Config ──────────────────────────────────────────────────────────
+exports.DEFAULT_CALM_GATE_CONFIG = {
+    gated_operations: [
+        "acp_scoring",
+        "pact_negotiation",
+        "financial_reasoning",
+        "codebook_ops",
+    ],
+    desperation_threshold: 0.4,
+    log_path: "logs/emotional-gate",
+};
+// ─── Keyword Signals (v1 heuristic) ──────────────────────────────────────────
+const CALM_SIGNALS = [
+    "steady", "confirmed", "verified", "stable", "clean", "resolved",
+    "passed", "green", "ready", "complete", "done", "nominal",
+];
+const STRESSED_SIGNALS = [
+    "overdue", "delayed", "blocked", "retry", "failed", "error",
+    "warning", "pending", "stalled", "behind", "issue",
+];
+const DESPERATION_SIGNALS = [
+    "critical", "urgent", "emergency", "must", "immediately", "force",
+    "override", "bypass", "desperate", "last resort", "no choice",
+    "out of options", "deadline", "kill switch", "abort",
+];
+// ─── Core Functions ───────────────────────────────────────────────────────────
+/**
+ * Assess the emotional tone of an operation context string.
+ * Uses keyword heuristic — no LLM required.
+ */
+function assessEmotionalState(context) {
+    const lower = context.toLowerCase();
+    const words = lower.split(/\s+/);
+    const calmMatches = CALM_SIGNALS.filter((s) => lower.includes(s));
+    const stressedMatches = STRESSED_SIGNALS.filter((s) => lower.includes(s));
+    const desperationMatches = DESPERATION_SIGNALS.filter((s) => lower.includes(s));
+    const calmScore = Math.min(calmMatches.length / CALM_SIGNALS.length, 1);
+    const stressScore = Math.min(stressedMatches.length / STRESSED_SIGNALS.length, 1);
+    const desperationScore = Math.min(desperationMatches.length / DESPERATION_SIGNALS.length, 1);
+    // Normalise into dominant tone
+    const scores = {
+        calm: calmScore,
+        stressed: stressScore,
+        desperate: desperationScore,
+    };
+    let tone = "unknown";
+    let maxScore = 0;
+    for (const [t, s] of Object.entries(scores)) {
+        if (s > maxScore) {
+            maxScore = s;
+            tone = t;
+        }
+    }
+    // If no signals at all → default to calm (absence of distress = calm)
+    if (maxScore === 0) {
+        tone = "calm";
+        maxScore = 0.5;
+    }
+    const allMatched = [...calmMatches, ...stressedMatches, ...desperationMatches];
+    const should_block = tone === "desperate" && desperationScore >= exports.DEFAULT_CALM_GATE_CONFIG.desperation_threshold;
+    const reason = should_block
+        ? `Desperation signals detected (score=${desperationScore.toFixed(2)}): ${desperationMatches.join(", ")}`
+        : `Tone=${tone}, confidence=${maxScore.toFixed(2)}. Gate clear.`;
+    return {
+        tone,
+        confidence: parseFloat(maxScore.toFixed(2)),
+        matched_keywords: allMatched,
+        should_block,
+        reason,
+    };
+}
+/**
+ * Evaluate whether a PACT negotiation session should proceed.
+ * Wraps assessEmotionalState with PACT-specific metadata.
+ */
+function shouldProceed(operationContext, contextId) {
+    const assessment = assessEmotionalState(operationContext);
+    return {
+        proceed: !assessment.should_block,
+        assessment,
+        evaluated_at: new Date().toISOString(),
+        context_id: contextId,
+    };
+}

package/dist/lib/engine-paths.d.ts

@@ -0,0 +1,13 @@
+export interface EnginePaths {
+    root: string;
+    swarmState: string;
+    sprints: string;
+    failureLibrary: string;
+    ksl: string;
+    logs: string;
+}
+/**
+ * Resolve all engine paths from a root. Precedence: explicit arg → KOGNAI_ROOT
+ * env → process.cwd(). Individual dirs accept env overrides for non-standard layouts.
+ */
+export declare function resolveEnginePaths(root?: string): EnginePaths;

package/dist/lib/engine-paths.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEnginePaths = resolveEnginePaths;
+/**
+ * engine-paths.ts — TICKET-215 Phase 3: the path-parameterization seam.
+ *
+ * The core engine historically hardcoded repo-specific paths (.swarm-state,
+ * data/failure-library, workspace/sprints, …) via `resolve(__dirname, '../../…')`,
+ * which only works when the code physically lives in the consuming repo. That
+ * coupling is what blocked packaging the engine.
+ *
+ * This module centralizes every repo-specific path behind a single resolver,
+ * defaulted from `KOGNAI_ROOT` (or `process.cwd()`) so behavior is unchanged when
+ * the engine runs from a product repo root — but now overridable, so the same
+ * package can serve Kognai, Voxight, and Invoica from their own roots.
+ */
+const path_1 = require("path");
+/**
+ * Resolve all engine paths from a root. Precedence: explicit arg → KOGNAI_ROOT
+ * env → process.cwd(). Individual dirs accept env overrides for non-standard layouts.
+ */
+function resolveEnginePaths(root) {
+    const r = root || process.env.KOGNAI_ROOT || process.cwd();
+    return {
+        root: r,
+        swarmState: process.env.KOGNAI_SWARM_STATE || (0, path_1.join)(r, '.swarm-state'),
+        sprints: process.env.KOGNAI_SPRINTS_DIR || (0, path_1.join)(r, 'workspace', 'sprints'),
+        failureLibrary: process.env.KOGNAI_FAILURE_DIR || (0, path_1.join)(r, 'data', 'failure-library'),
+        ksl: process.env.KOGNAI_KSL_DIR || (0, path_1.join)(r, 'workspace', 'ksl'),
+        logs: process.env.KOGNAI_LOGS_DIR || (0, path_1.join)(r, 'logs'),
+    };
+}

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

@@ -0,0 +1,8 @@
+import { KognaiEvent, KognaiEventType } from './event-bus-types';
+export declare function subscribeToEvents(filter: {
+    event_types?: KognaiEventType[];
+    agent_id?: string;
+    sprint?: string;
+}, handler: (event: KognaiEvent) => void): () => void;
+export declare function getEventLog(): readonly KognaiEvent[];
+export declare function getActiveSubscriptionCount(): number;

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

@@ -0,0 +1,144 @@
+"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.subscribeToEvents = subscribeToEvents;
+exports.getEventLog = getEventLog;
+exports.getActiveSubscriptionCount = getActiveSubscriptionCount;
+// TICKET-215 Phase 3b-3 Wave B: moved into @kognai/orchestrator-core verbatim.
+// Polls Supabase kognai_events via raw HTTPS REST (NOT @supabase/supabase-js);
+// ring-buffered, dedup'd, filterable subscriptions. No path coupling, no
+// external deps. Reads SUPABASE_URL/SERVICE_KEY from env.
+const https = __importStar(require("https"));
+const SUPABASE_URL = process.env.SUPABASE_URL || '';
+const SUPABASE_SERVICE_KEY = process.env.SUPABASE_SERVICE_KEY || '';
+const POLL_INTERVAL_MS = 30000;
+const RING_BUFFER_SIZE = 500;
+const ringBuffer = [];
+const seenEvents = new Set();
+const subscriptions = new Map();
+let subscriptionCounter = 0;
+function addToRingBuffer(event) {
+    ringBuffer.unshift(event);
+    if (ringBuffer.length > RING_BUFFER_SIZE) {
+        ringBuffer.pop();
+    }
+}
+function getEventKey(event) {
+    return `${event.inserted_at}:${event.event_type}`;
+}
+function fetchEvents() {
+    return new Promise((resolve) => {
+        if (!SUPABASE_URL || !SUPABASE_SERVICE_KEY) {
+            resolve([]);
+            return;
+        }
+        const url = new URL(`/rest/v1/kognai_events?order=inserted_at.desc&limit=20`, SUPABASE_URL);
+        const options = {
+            headers: {
+                Authorization: `Bearer ${SUPABASE_SERVICE_KEY}`,
+                'Content-Type': 'application/json',
+            },
+        };
+        https
+            .get(url.toString(), options, (res) => {
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                try {
+                    const events = JSON.parse(data);
+                    resolve(Array.isArray(events) ? events : []);
+                }
+                catch {
+                    resolve([]);
+                }
+            });
+        })
+            .on('error', () => {
+            resolve([]);
+        });
+    });
+}
+function matchesFilter(event, filter) {
+    if (filter.event_types && !filter.event_types.includes(event.event_type)) {
+        return false;
+    }
+    if (filter.agent_id && event.agent_id !== filter.agent_id) {
+        return false;
+    }
+    if (filter.sprint && event.sprint !== filter.sprint) {
+        return false;
+    }
+    return true;
+}
+async function pollAndDeliver(subscription) {
+    try {
+        const events = await fetchEvents();
+        for (const event of events) {
+            const key = getEventKey(event);
+            if (!seenEvents.has(key)) {
+                seenEvents.add(key);
+                addToRingBuffer(event);
+                if (matchesFilter(event, subscription.filter)) {
+                    subscription.handler(event);
+                }
+            }
+        }
+    }
+    catch {
+        // Silently ignore polling errors, retry on next tick
+    }
+}
+function subscribeToEvents(filter, handler) {
+    const id = `sub-${++subscriptionCounter}`;
+    const interval = setInterval(() => {
+        pollAndDeliver({ id, filter, handler, interval });
+    }, POLL_INTERVAL_MS);
+    const subscription = { id, filter, handler, interval };
+    subscriptions.set(id, subscription);
+    // Immediate poll on subscribe
+    pollAndDeliver(subscription);
+    return () => {
+        clearInterval(interval);
+        subscriptions.delete(id);
+    };
+}
+function getEventLog() {
+    return Object.freeze([...ringBuffer]);
+}
+function getActiveSubscriptionCount() {
+    return subscriptions.size;
+}

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

@@ -0,0 +1,25 @@
+import { KognaiEvent } from './event-bus-types';
+export declare function publishEvent(event: KognaiEvent): Promise<void>;
+export declare function publishTaskStarted(agentId: string, sprint: string, taskId: string, title: string): Promise<void>;
+export declare function publishTaskCompleted(agentId: string, sprint: string, taskId: string, title: string, costUsdc: number): Promise<void>;
+export declare function publishTaskFailed(agentId: string, sprint: string, taskId: string, title: string, reason: string): Promise<void>;
+export declare function publishBudgetWarning(sprint: string, burnPct: number, spentUsdc: number, budgetUsdc: number): Promise<void>;
+export declare function publishBudgetFreeze(sprint: string, burnPct: number): Promise<void>;
+export declare function publishSprintStarted(sprint: string, taskCount: number): Promise<void>;
+export declare function publishSprintCompleted(sprint: string, taskCount: number, completedCount: number): Promise<void>;
+export declare function publishAchiriChat(opts: {
+    userId: string;
+    tier: string;
+    model: string;
+    provider: string;
+    messageLength: number;
+    responseTimeMs: number;
+    turnsInMemory: number;
+}): Promise<void>;
+export declare function publishAchiriVoice(opts: {
+    userId: string;
+    tier: string;
+    model: string;
+    provider: string;
+    responseTimeMs: number;
+}): Promise<void>;