@kernel.chat/kbot 4.0.0 → 4.1.0

package/dist/futures/harness/evolution-loop.js

@@ -0,0 +1,168 @@
+/**
+ * Harness Evolution Loop — inner loop (Algorithm 1 from Sylph).
+ *
+ *   for i in 1..maxIterations:
+ *     trace   = Worker.execute(task, harness)
+ *     report  = Evaluator.evaluate(trace, task)
+ *     record  = { iteration, harness, trace, report, verdict }
+ *     history.push(record)
+ *     if report.score > bestScore: best = harness
+ *     if earlyStopScore reached on consecutive iterations: stop
+ *     if regression > revertThreshold: revert harness to best
+ *     harness = EvolutionAgent.evolve(history, best)
+ *
+ * Pure orchestration — Worker / Evaluator / EvolutionAgent are injected,
+ * which makes the whole loop deterministic and testable with stub
+ * implementations. No LLM calls happen here directly.
+ */
+import { appendTrace } from './persistence.js';
+function compareVerdict(prev, current, revertThreshold) {
+    if (current > prev)
+        return 'improved';
+    if (current === prev)
+        return 'no-op';
+    if (revertThreshold !== undefined && (prev - current) >= revertThreshold) {
+        // A "regressed" verdict signals the loop should revert to best harness.
+        return 'regressed';
+    }
+    return 'regressed';
+}
+/**
+ * Run the inner Harness Evolution Loop against a single task.
+ *
+ * Always returns an `EvolutionResult` — never throws on Worker / Evaluator
+ * exceptions; instead, records a failure step and continues. (The
+ * Evaluator is supposed to score failures, not the loop itself.)
+ */
+export async function runEvolutionLoop(protocol, task, options = {}) {
+    const { worker, evaluator, evolution, initialHarness, hyperparams } = protocol;
+    const maxIterations = Math.max(1, hyperparams.maxIterations | 0);
+    const earlyStopScore = hyperparams.earlyStopScore;
+    const revertThreshold = hyperparams.revertThreshold;
+    const earlyStopStreak = Math.max(1, options.earlyStopStreak ?? 1);
+    const shouldPersist = options.persist !== false && !!options.persistDir;
+    const history = [];
+    let harness = initialHarness;
+    let bestHarness = initialHarness;
+    let bestScore = -Infinity;
+    let prevScore = -Infinity;
+    let earlyHits = 0;
+    for (let iteration = 1; iteration <= maxIterations; iteration++) {
+        let trace;
+        try {
+            trace = await worker.execute(task, harness);
+        }
+        catch (err) {
+            // Synthesize a minimal failure trace so the evaluator can still grade.
+            trace = {
+                taskId: task.id,
+                harnessId: harness.id,
+                steps: [
+                    {
+                        index: 0,
+                        phase: 'observe',
+                        action: 'worker-error',
+                        error: err instanceof Error ? err.message : String(err),
+                        durationMs: 0,
+                    },
+                ],
+                finalState: {},
+                llmTimeMs: 0,
+                toolTimeMs: 0,
+            };
+        }
+        let report;
+        try {
+            report = await evaluator.evaluate(trace, task);
+        }
+        catch (err) {
+            report = {
+                taskId: task.id,
+                harnessId: harness.id,
+                pass: false,
+                score: 0,
+                criteriaResults: task.acceptance.map((c) => ({
+                    criterion: c,
+                    passed: false,
+                    evidence: 'evaluator-error',
+                })),
+                failureModes: [
+                    {
+                        kind: 'other',
+                        detail: err instanceof Error ? err.message : String(err),
+                    },
+                ],
+                notes: 'evaluator threw; auto-fail',
+            };
+        }
+        const verdict = compareVerdict(prevScore, report.score, revertThreshold);
+        const record = {
+            iteration,
+            harness,
+            trace,
+            report,
+            verdict,
+        };
+        history.push(record);
+        if (options.onRecord) {
+            await options.onRecord(record);
+        }
+        if (shouldPersist) {
+            try {
+                await appendTrace(task.id, record, options.persistDir);
+            }
+            catch {
+                // persistence is best-effort; never block evolution on disk failure
+            }
+        }
+        // Track best harness.
+        if (report.score > bestScore) {
+            bestScore = report.score;
+            bestHarness = harness;
+        }
+        // Early-stop check.
+        if (earlyStopScore !== undefined && report.score >= earlyStopScore) {
+            earlyHits++;
+            if (earlyHits >= earlyStopStreak) {
+                break;
+            }
+        }
+        else {
+            earlyHits = 0;
+        }
+        // Revert on regression past threshold.
+        if (revertThreshold !== undefined &&
+            bestScore - report.score >= revertThreshold) {
+            harness = bestHarness;
+        }
+        prevScore = report.score;
+        // Short-circuit before the final evolve call — no point mutating on the
+        // last iteration since we'll never execute the new harness.
+        if (iteration === maxIterations)
+            break;
+        try {
+            harness = await evolution.evolve(history, bestHarness);
+        }
+        catch {
+            // EvolutionAgent failed — keep current harness, keep going.
+            harness = bestHarness;
+        }
+    }
+    // If nothing ran (shouldn't happen with maxIterations >= 1) make sure
+    // bestHarness is still defined.
+    if (history.length === 0) {
+        return {
+            taskId: task.id,
+            bestHarness: initialHarness,
+            bestScore: 0,
+            history,
+        };
+    }
+    return {
+        taskId: task.id,
+        bestHarness,
+        bestScore: bestScore === -Infinity ? 0 : bestScore,
+        history,
+    };
+}
+//# sourceMappingURL=evolution-loop.js.map

package/dist/futures/harness/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Harness Evolution Loop — public surface.
+ *
+ * See `./README.md` for the high-level overview and `./types.ts` for the
+ * contract every other file in this directory targets.
+ */
+export * from './types.js';
+export { runEvolutionLoop } from './evolution-loop.js';
+export type { RunOptions } from './evolution-loop.js';
+export { runMetaEvolution } from './meta-evolution.js';
+export type { MetaOptions } from './meta-evolution.js';
+export { CriticEvaluator, createCriticEvaluator, } from './critic-evaluator.js';
+export type { CriticEvaluatorOpts } from './critic-evaluator.js';
+export { NoopEvolutionAgent, createNoopEvolutionAgent, } from './noop-evolution.js';
+export { appendTrace, readHistory, pruneOlderThan, defaultStateDir, } from './persistence.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/futures/harness/index.js

@@ -0,0 +1,13 @@
+/**
+ * Harness Evolution Loop — public surface.
+ *
+ * See `./README.md` for the high-level overview and `./types.ts` for the
+ * contract every other file in this directory targets.
+ */
+export * from './types.js';
+export { runEvolutionLoop } from './evolution-loop.js';
+export { runMetaEvolution } from './meta-evolution.js';
+export { CriticEvaluator, createCriticEvaluator, } from './critic-evaluator.js';
+export { NoopEvolutionAgent, createNoopEvolutionAgent, } from './noop-evolution.js';
+export { appendTrace, readHistory, pruneOlderThan, defaultStateDir, } from './persistence.js';
+//# sourceMappingURL=index.js.map

package/dist/futures/harness/meta-evolution.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Harness Meta-Evolution — outer loop (Algorithm 2 from Sylph).
+ *
+ * The inner loop optimizes one harness against one task. The outer loop
+ * runs the inner loop across a portfolio of tasks, aggregating per-task
+ * results and selecting the best protocol overall. Currently the
+ * "selection" step is averaging — when a real MetaEvolutionAgent ships,
+ * it'll consume the perTask EvolutionResult[] and propose protocol
+ * mutations.
+ *
+ * Pure orchestration. Tasks are run sequentially to keep the trace
+ * ordering deterministic; parallelism is a future concern.
+ */
+import type { EvolutionProtocol, EvolutionResult, MetaResult, Task } from './types.js';
+import { type RunOptions } from './evolution-loop.js';
+export interface MetaOptions extends RunOptions {
+    /** Called after each task's inner loop completes. */
+    onTaskComplete?: (result: EvolutionResult) => void | Promise<void>;
+    /**
+     * When `true`, abort the outer loop on the first task whose best score
+     * is below `failBelow`. Default false — always run the full portfolio.
+     */
+    abortOnFailure?: boolean;
+    failBelow?: number;
+}
+/**
+ * Run the inner Evolution Loop across a portfolio of tasks, returning
+ * the best protocol (currently always the input protocol — there is no
+ * MetaEvolutionAgent yet) plus per-task results and the aggregate score.
+ */
+export declare function runMetaEvolution(protocol: EvolutionProtocol, tasks: Task[], options?: MetaOptions): Promise<MetaResult>;
+//# sourceMappingURL=meta-evolution.d.ts.map

package/dist/futures/harness/meta-evolution.js

@@ -0,0 +1,52 @@
+/**
+ * Harness Meta-Evolution — outer loop (Algorithm 2 from Sylph).
+ *
+ * The inner loop optimizes one harness against one task. The outer loop
+ * runs the inner loop across a portfolio of tasks, aggregating per-task
+ * results and selecting the best protocol overall. Currently the
+ * "selection" step is averaging — when a real MetaEvolutionAgent ships,
+ * it'll consume the perTask EvolutionResult[] and propose protocol
+ * mutations.
+ *
+ * Pure orchestration. Tasks are run sequentially to keep the trace
+ * ordering deterministic; parallelism is a future concern.
+ */
+import { runEvolutionLoop } from './evolution-loop.js';
+/**
+ * Run the inner Evolution Loop across a portfolio of tasks, returning
+ * the best protocol (currently always the input protocol — there is no
+ * MetaEvolutionAgent yet) plus per-task results and the aggregate score.
+ */
+export async function runMetaEvolution(protocol, tasks, options = {}) {
+    if (tasks.length === 0) {
+        return {
+            bestProtocol: protocol,
+            bestMetaScore: 0,
+            perTask: [],
+        };
+    }
+    const perTask = [];
+    let scoreSum = 0;
+    for (const task of tasks) {
+        const result = await runEvolutionLoop(protocol, task, options);
+        perTask.push(result);
+        scoreSum += result.bestScore;
+        if (options.onTaskComplete) {
+            await options.onTaskComplete(result);
+        }
+        if (options.abortOnFailure &&
+            options.failBelow !== undefined &&
+            result.bestScore < options.failBelow) {
+            break;
+        }
+    }
+    // Aggregate score: mean of per-task best scores. Cheap, defensible, and
+    // matches the "average across tasks" framing in the Sylph outer loop.
+    const meanScore = perTask.length > 0 ? scoreSum / perTask.length : 0;
+    return {
+        bestProtocol: protocol,
+        bestMetaScore: meanScore,
+        perTask,
+    };
+}
+//# sourceMappingURL=meta-evolution.js.map

package/dist/futures/harness/noop-evolution.d.ts

@@ -0,0 +1,23 @@
+/**
+ * No-op EvolutionAgent — records but never rewrites the harness.
+ *
+ * The Sylph paper's outer-loop value comes from the EvolutionAgent
+ * mutating the harness based on history. Real, safe code rewriting is a
+ * multi-month problem; this stub satisfies the interface so the inner
+ * loop runs end-to-end. Every other piece of the substrate (trace
+ * persistence, regression detection, A/B evaluation, harness diffing)
+ * works without any actual mutation.
+ *
+ * The contract is met; the substrate is shipped.
+ */
+import type { EvolutionAgent, EvolutionRecord, Harness } from './types.js';
+export declare class NoopEvolutionAgent implements EvolutionAgent {
+    /**
+     * Returns the input harness unchanged. Reads `history` only to allow
+     * subclasses to subscribe to inspection without forcing a re-read.
+     */
+    evolve(history: EvolutionRecord[], best: Harness): Promise<Harness>;
+}
+/** Convenience factory mirroring the rest of the futures module style. */
+export declare function createNoopEvolutionAgent(): EvolutionAgent;
+//# sourceMappingURL=noop-evolution.d.ts.map

package/dist/futures/harness/noop-evolution.js

@@ -0,0 +1,29 @@
+/**
+ * No-op EvolutionAgent — records but never rewrites the harness.
+ *
+ * The Sylph paper's outer-loop value comes from the EvolutionAgent
+ * mutating the harness based on history. Real, safe code rewriting is a
+ * multi-month problem; this stub satisfies the interface so the inner
+ * loop runs end-to-end. Every other piece of the substrate (trace
+ * persistence, regression detection, A/B evaluation, harness diffing)
+ * works without any actual mutation.
+ *
+ * The contract is met; the substrate is shipped.
+ */
+export class NoopEvolutionAgent {
+    /**
+     * Returns the input harness unchanged. Reads `history` only to allow
+     * subclasses to subscribe to inspection without forcing a re-read.
+     */
+    async evolve(history, best) {
+        // Touch parameters explicitly so the type-checker stays happy in strict
+        // mode and the intent — "we saw history, we chose not to act" — is clear.
+        void history;
+        return best;
+    }
+}
+/** Convenience factory mirroring the rest of the futures module style. */
+export function createNoopEvolutionAgent() {
+    return new NoopEvolutionAgent();
+}
+//# sourceMappingURL=noop-evolution.js.map

package/dist/futures/harness/persistence.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Harness Evolution Loop — JSONL trace persistence.
+ *
+ * Each task gets its own append-only JSONL file at
+ * `~/.kbot/futures/harness/<task-id>.jsonl`. One line per `EvolutionRecord`
+ * (or arbitrary JSON-serializable record). Append-only on the hot path so
+ * concurrent loops don't trample each other; reads parse line-by-line and
+ * skip malformed lines rather than throwing on a single bad row.
+ *
+ * Pattern mirrors `src/planner/hierarchical/persistence.ts`: state dir is
+ * configurable (default `~/.kbot/futures/harness`), atomic writes where
+ * possible, ENOENT swallowed on read paths.
+ */
+import type { EvolutionRecord } from './types.js';
+/** Default on-disk root: `~/.kbot/futures/harness/`. */
+export declare function defaultStateDir(): string;
+/** Append a single record as one JSONL line. */
+export declare function appendTrace(taskId: string, record: EvolutionRecord, stateDir?: string): Promise<void>;
+/**
+ * Read all records for a task in append order. Returns empty array if the
+ * file doesn't exist. Malformed lines are skipped — one bad row never
+ * invalidates the whole history.
+ */
+export declare function readHistory(taskId: string, stateDir?: string): Promise<EvolutionRecord[]>;
+/**
+ * Delete trace files older than `days` (by mtime). Returns the list of
+ * removed task ids. Pure janitor — never throws on individual failures.
+ */
+export declare function pruneOlderThan(days: number, stateDir?: string): Promise<string[]>;
+//# sourceMappingURL=persistence.d.ts.map

package/dist/futures/harness/persistence.js

@@ -0,0 +1,99 @@
+/**
+ * Harness Evolution Loop — JSONL trace persistence.
+ *
+ * Each task gets its own append-only JSONL file at
+ * `~/.kbot/futures/harness/<task-id>.jsonl`. One line per `EvolutionRecord`
+ * (or arbitrary JSON-serializable record). Append-only on the hot path so
+ * concurrent loops don't trample each other; reads parse line-by-line and
+ * skip malformed lines rather than throwing on a single bad row.
+ *
+ * Pattern mirrors `src/planner/hierarchical/persistence.ts`: state dir is
+ * configurable (default `~/.kbot/futures/harness`), atomic writes where
+ * possible, ENOENT swallowed on read paths.
+ */
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+/** Default on-disk root: `~/.kbot/futures/harness/`. */
+export function defaultStateDir() {
+    return path.join(os.homedir(), '.kbot', 'futures', 'harness');
+}
+function safeId(taskId) {
+    // Restrict to filesystem-safe chars; collapse anything else to '_'.
+    return taskId.replace(/[^a-zA-Z0-9._-]/g, '_');
+}
+function tracePath(stateDir, taskId) {
+    return path.join(stateDir, `${safeId(taskId)}.jsonl`);
+}
+async function ensureDir(dir) {
+    await fs.mkdir(dir, { recursive: true });
+}
+/** Append a single record as one JSONL line. */
+export async function appendTrace(taskId, record, stateDir = defaultStateDir()) {
+    await ensureDir(stateDir);
+    const line = JSON.stringify(record) + '\n';
+    await fs.appendFile(tracePath(stateDir, taskId), line, 'utf8');
+}
+/**
+ * Read all records for a task in append order. Returns empty array if the
+ * file doesn't exist. Malformed lines are skipped — one bad row never
+ * invalidates the whole history.
+ */
+export async function readHistory(taskId, stateDir = defaultStateDir()) {
+    let raw;
+    try {
+        raw = await fs.readFile(tracePath(stateDir, taskId), 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    }
+    const out = [];
+    for (const line of raw.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            out.push(JSON.parse(trimmed));
+        }
+        catch {
+            // skip malformed line
+        }
+    }
+    return out;
+}
+/**
+ * Delete trace files older than `days` (by mtime). Returns the list of
+ * removed task ids. Pure janitor — never throws on individual failures.
+ */
+export async function pruneOlderThan(days, stateDir = defaultStateDir()) {
+    const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+    let entries;
+    try {
+        entries = await fs.readdir(stateDir);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    }
+    const removed = [];
+    for (const entry of entries) {
+        if (!entry.endsWith('.jsonl'))
+            continue;
+        const full = path.join(stateDir, entry);
+        try {
+            const stat = await fs.stat(full);
+            if (stat.mtimeMs < cutoff) {
+                await fs.unlink(full);
+                removed.push(entry.replace(/\.jsonl$/, ''));
+            }
+        }
+        catch {
+            // skip — permission, race, etc.
+        }
+    }
+    return removed;
+}
+//# sourceMappingURL=persistence.js.map

package/dist/futures/harness/types.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Harness Evolution Loop — type definitions.
+ *
+ * Maps onto the formalism from "The Last Harness You'll Ever Build"
+ * (Seong, Yin, Zhang — Sylph.AI, arXiv:2604.21003):
+ *
+ *   Agent = Model + Harness
+ *   Harness = prompts + tools + orchestration + hooks + model config
+ *
+ *   Inner loop:  Worker(τ)        → Evaluator(τ) → EvolutionAgent(history) → H'
+ *   Outer loop:  HarnessEvolution × N tasks → MetaEvolutionAgent(history) → Λ'
+ *
+ * This module is types-only. Runtime lives in evolution-loop.ts and
+ * meta-evolution.ts. No imports from heavy modules so it can be loaded by
+ * tools, tests, and remote runners cheaply.
+ */
+/** Identifier for a single task instance the worker is being optimized against. */
+export interface Task {
+    id: string;
+    /** Concrete instructions the worker reads. */
+    instructions: string;
+    /** Verifiable success criteria — the evaluator's checklist. */
+    acceptance: string[];
+    /** Optional free-form metadata (domain, expected runtime, etc.). */
+    meta?: Record<string, unknown>;
+}
+/**
+ * The harness — every piece of code/config that surrounds the model.
+ * Kept as data so it can be diffed, persisted, and rewritten by EvolutionAgent.
+ */
+export interface Harness {
+    /** Stable identifier; new id on every evolution step. */
+    id: string;
+    systemPrompt: string;
+    /** Tool names the worker is allowed to call. */
+    toolAllowlist: string[];
+    /** Hooks/middleware applied around tool calls. */
+    hooks: HookSpec[];
+    /** Model routing — which model handles which subtask kind. */
+    modelRouting: ModelRoute[];
+    /** Loop hyperparameters: max iterations, parallelism, revert thresholds. */
+    hyperparams: Hyperparams;
+}
+export interface HookSpec {
+    name: string;
+    /** When to fire: before tool call, after, on error, etc. */
+    phase: 'pre-tool' | 'post-tool' | 'on-error' | 'pre-response';
+    /** Free-form config; the runtime resolves to actual hook code. */
+    config?: Record<string, unknown>;
+}
+export interface ModelRoute {
+    /** Pattern match on task kind / tool / phase. */
+    match: string;
+    model: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+export interface Hyperparams {
+    maxIterations: number;
+    /** Stop early if score >= this on successive iterations. */
+    earlyStopScore?: number;
+    /** If a step regresses by more than this, revert to best. */
+    revertThreshold?: number;
+}
+/** Trace produced by Worker.execute() for the Evaluator to inspect. */
+export interface ExecutionTrace {
+    taskId: string;
+    harnessId: string;
+    steps: TraceStep[];
+    finalState: Record<string, unknown>;
+    llmTimeMs: number;
+    toolTimeMs: number;
+}
+export interface TraceStep {
+    index: number;
+    phase: 'plan' | 'tool' | 'response' | 'observe';
+    action: string;
+    output?: string;
+    error?: string;
+    durationMs: number;
+}
+/** Evaluator output: pass/fail + score + diagnostic narrative. */
+export interface EvaluationReport {
+    taskId: string;
+    harnessId: string;
+    pass: boolean;
+    /** Two-tier score: pass yields 1.0, scaled by efficiency tiebreaker. */
+    score: number;
+    /** Per-criterion verdict. Length matches Task.acceptance. */
+    criteriaResults: CriterionResult[];
+    /** Categorized failure modes for the Evolution Agent to act on. */
+    failureModes: FailureMode[];
+    /** Free-form diagnostic prose. */
+    notes?: string;
+}
+export interface CriterionResult {
+    criterion: string;
+    passed: boolean;
+    evidence?: string;
+}
+export type FailureModeKind = 'incorrect-tool-usage' | 'reasoning-loop' | 'misinterpreted-state' | 'excessive-latency' | 'missing-capability' | 'hallucinated-state' | 'other';
+export interface FailureMode {
+    kind: FailureModeKind;
+    detail: string;
+}
+/** One row in the evolution history. */
+export interface EvolutionRecord {
+    iteration: number;
+    harness: Harness;
+    trace: ExecutionTrace;
+    report: EvaluationReport;
+    verdict: 'improved' | 'regressed' | 'no-op';
+}
+/** Final result of a single inner-loop run. */
+export interface EvolutionResult {
+    taskId: string;
+    bestHarness: Harness;
+    bestScore: number;
+    history: EvolutionRecord[];
+}
+/** Worker = the agent under optimization, parameterized by harness. */
+export interface Worker {
+    execute(task: Task, harness: Harness): Promise<ExecutionTrace>;
+}
+/** Evaluator = adversarial reviewer; produces EvaluationReport. */
+export interface Evaluator {
+    evaluate(trace: ExecutionTrace, task: Task): Promise<EvaluationReport>;
+}
+/** EvolutionAgent = mutates the harness based on history. */
+export interface EvolutionAgent {
+    evolve(history: EvolutionRecord[], best: Harness): Promise<Harness>;
+}
+/** Λ — the evolution protocol itself. */
+export interface EvolutionProtocol {
+    worker: Worker;
+    evaluator: Evaluator;
+    evolution: EvolutionAgent;
+    initialHarness: Harness;
+    hyperparams: Hyperparams;
+}
+/** Outer-loop result. */
+export interface MetaResult {
+    bestProtocol: EvolutionProtocol;
+    bestMetaScore: number;
+    perTask: EvolutionResult[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/futures/harness/types.js

@@ -0,0 +1,18 @@
+/**
+ * Harness Evolution Loop — type definitions.
+ *
+ * Maps onto the formalism from "The Last Harness You'll Ever Build"
+ * (Seong, Yin, Zhang — Sylph.AI, arXiv:2604.21003):
+ *
+ *   Agent = Model + Harness
+ *   Harness = prompts + tools + orchestration + hooks + model config
+ *
+ *   Inner loop:  Worker(τ)        → Evaluator(τ) → EvolutionAgent(history) → H'
+ *   Outer loop:  HarnessEvolution × N tasks → MetaEvolutionAgent(history) → Λ'
+ *
+ * This module is types-only. Runtime lives in evolution-loop.ts and
+ * meta-evolution.ts. No imports from heavy modules so it can be loaded by
+ * tools, tests, and remote runners cheaply.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/futures/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * kbot v5 futures — experimental architectural skeleton.
+ *
+ * Six modules drawn from frontier research published in late April 2026.
+ * Each is opt-in, additive, and reversible. None of them changes default
+ * agent behavior unless explicitly invoked.
+ *
+ * Plan: packages/kbot/V5_FUTURES_PLAN.md
+ */
+export * as harness from './harness/index.js';
+export * as skillGraph from './skill-graph/index.js';
+export * as latentState from './latent-state/index.js';
+export * as forecast from './forecast/index.js';
+export * as persona from './persona/index.js';
+export * as debate from './debate/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/futures/index.js

@@ -0,0 +1,22 @@
+/**
+ * kbot v5 futures — experimental architectural skeleton.
+ *
+ * Six modules drawn from frontier research published in late April 2026.
+ * Each is opt-in, additive, and reversible. None of them changes default
+ * agent behavior unless explicitly invoked.
+ *
+ * Plan: packages/kbot/V5_FUTURES_PLAN.md
+ */
+// Harness Evolution Loop — Sylph.AI 2604.21003
+export * as harness from './harness/index.js';
+// Skill Graph — Tencent Hunyuan 2604.25727
+export * as skillGraph from './skill-graph/index.js';
+// Latent State Envelope — Recursive MAS 2604.25917
+export * as latentState from './latent-state/index.js';
+// Forecast — predictions module
+export * as forecast from './forecast/index.js';
+// Persona — privilege scoping (Cequence)
+export * as persona from './persona/index.js';
+// Debate — BARRED-style asymmetric debate runner
+export * as debate from './debate/index.js';
+//# sourceMappingURL=index.js.map