@kernel.chat/kbot 4.0.1 → 4.1.1

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

package/dist/futures/latent-state/envelope.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Latent-state envelope — runtime helpers.
+ * Pure functions over `LatentEnvelope`. Node `crypto` (sha256) for hashing.
+ */
+import type { LatentEnvelope, ProvenanceEntry } from './types.js';
+/** JSON.stringify with deterministic key order (Object.keys().sort()). */
+export declare function stableStringify(value: unknown): string;
+export interface CreateEnvelopeOpts {
+    from: string;
+    to: string;
+    text?: string;
+    structured?: Record<string, unknown>;
+    createdAt?: string;
+    note?: string;
+}
+/**
+ * Build a fresh envelope. Auto-derives `kind`, stamps `createdAt`, seeds
+ * provenance with a single step from `opts.from`, and computes `contentHash`.
+ */
+export declare function createEnvelope(opts: CreateEnvelopeOpts): LatentEnvelope;
+/** JSON-serialize an envelope with stable key order. */
+export declare function serialize(env: LatentEnvelope): string;
+/** Parse, validate shape, recompute hash, throw if mismatch. */
+export declare function deserialize(s: string): LatentEnvelope;
+/** True iff stored `contentHash` matches a fresh hash of the body. */
+export declare function verifyHash(env: LatentEnvelope): boolean;
+/** Append a provenance step and rehash. Returns a new envelope. */
+export declare function withProvenance(env: LatentEnvelope, entry: Omit<ProvenanceEntry, 'step'> & {
+    step?: number;
+}): LatentEnvelope;
+/**
+ * Combine two envelopes from the same from/to pair.
+ * - text: a + '\n' + b
+ * - structured: shallow merge with one-level deep-merge for plain objects
+ * - provenance: a then b, renumbered sequentially
+ * - createdAt: fresh ISO timestamp; contentHash: recomputed
+ */
+export declare function merge(a: LatentEnvelope, b: LatentEnvelope): LatentEnvelope;
+//# sourceMappingURL=envelope.d.ts.map

package/dist/futures/latent-state/envelope.js

@@ -0,0 +1,178 @@
+/**
+ * Latent-state envelope — runtime helpers.
+ * Pure functions over `LatentEnvelope`. Node `crypto` (sha256) for hashing.
+ */
+import { createHash } from 'node:crypto';
+/** JSON.stringify with deterministic key order (Object.keys().sort()). */
+export function stableStringify(value) {
+    return JSON.stringify(canonicalize(value));
+}
+function canonicalize(value) {
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    const obj = value;
+    const out = {};
+    for (const key of Object.keys(obj).sort())
+        out[key] = canonicalize(obj[key]);
+    return out;
+}
+function hashableBody(env) {
+    return {
+        version: env.version, from: env.from, to: env.to, kind: env.kind,
+        text: env.text, structured: env.structured,
+        provenance: env.provenance, createdAt: env.createdAt,
+    };
+}
+function computeHash(env) {
+    return createHash('sha256').update(stableStringify(hashableBody(env))).digest('hex');
+}
+function classify(text, structured) {
+    if (text !== undefined && structured !== undefined)
+        return 'mixed';
+    if (structured !== undefined)
+        return 'structured';
+    return 'text';
+}
+/**
+ * Build a fresh envelope. Auto-derives `kind`, stamps `createdAt`, seeds
+ * provenance with a single step from `opts.from`, and computes `contentHash`.
+ */
+export function createEnvelope(opts) {
+    const kind = classify(opts.text, opts.structured);
+    const createdAt = opts.createdAt ?? new Date().toISOString();
+    const provenance = [
+        {
+            step: 1,
+            agent: opts.from,
+            ts: createdAt,
+            ...(opts.note !== undefined ? { note: opts.note } : {}),
+        },
+    ];
+    const body = {
+        version: 1,
+        from: opts.from,
+        to: opts.to,
+        kind,
+        ...(opts.text !== undefined ? { text: opts.text } : {}),
+        ...(opts.structured !== undefined ? { structured: opts.structured } : {}),
+        provenance,
+        createdAt,
+    };
+    return { ...body, contentHash: computeHash(body) };
+}
+/** JSON-serialize an envelope with stable key order. */
+export function serialize(env) {
+    return stableStringify(env);
+}
+/** Parse, validate shape, recompute hash, throw if mismatch. */
+export function deserialize(s) {
+    let raw;
+    try {
+        raw = JSON.parse(s);
+    }
+    catch (err) {
+        throw new Error(`latent-state: invalid JSON: ${err.message}`);
+    }
+    const env = assertShape(raw);
+    if (!verifyHash(env)) {
+        throw new Error('latent-state: contentHash mismatch — envelope tampered');
+    }
+    return env;
+}
+function assertShape(raw) {
+    if (!raw || typeof raw !== 'object')
+        throw new Error('latent-state: envelope must be an object');
+    const o = raw;
+    if (o.version !== 1)
+        throw new Error(`latent-state: unsupported version ${String(o.version)}`);
+    if (typeof o.from !== 'string' || typeof o.to !== 'string')
+        throw new Error('latent-state: from/to must be strings');
+    if (o.kind !== 'text' && o.kind !== 'structured' && o.kind !== 'mixed')
+        throw new Error(`latent-state: invalid kind ${String(o.kind)}`);
+    if (typeof o.createdAt !== 'string' || typeof o.contentHash !== 'string')
+        throw new Error('latent-state: createdAt/contentHash must be strings');
+    if (!Array.isArray(o.provenance) || o.provenance.length === 0)
+        throw new Error('latent-state: provenance must be a non-empty array');
+    return o;
+}
+/** True iff stored `contentHash` matches a fresh hash of the body. */
+export function verifyHash(env) {
+    const { contentHash, ...body } = env;
+    return computeHash(body) === contentHash;
+}
+/** Append a provenance step and rehash. Returns a new envelope. */
+export function withProvenance(env, entry) {
+    const nextStep = entry.step ?? Math.max(0, ...env.provenance.map((p) => p.step)) + 1;
+    const provenance = [
+        ...env.provenance,
+        {
+            step: nextStep,
+            agent: entry.agent,
+            ts: entry.ts,
+            ...(entry.note !== undefined ? { note: entry.note } : {}),
+        },
+    ];
+    const { contentHash: _drop, ...rest } = { ...env, provenance };
+    void _drop;
+    return { ...rest, contentHash: computeHash(rest) };
+}
+/**
+ * Combine two envelopes from the same from/to pair.
+ * - text: a + '\n' + b
+ * - structured: shallow merge with one-level deep-merge for plain objects
+ * - provenance: a then b, renumbered sequentially
+ * - createdAt: fresh ISO timestamp; contentHash: recomputed
+ */
+export function merge(a, b) {
+    if (a.from !== b.from || a.to !== b.to) {
+        throw new Error('latent-state: cannot merge envelopes with different from/to');
+    }
+    const text = mergeText(a.text, b.text);
+    const structured = mergeStructured(a.structured, b.structured);
+    const kind = classify(text, structured);
+    const provenance = [...a.provenance, ...b.provenance].map((p, i) => ({ ...p, step: i + 1 }));
+    const body = {
+        version: 1,
+        from: a.from,
+        to: a.to,
+        kind,
+        ...(text !== undefined ? { text } : {}),
+        ...(structured !== undefined ? { structured } : {}),
+        provenance,
+        createdAt: new Date().toISOString(),
+    };
+    return { ...body, contentHash: computeHash(body) };
+}
+function mergeText(a, b) {
+    if (a === undefined && b === undefined)
+        return undefined;
+    if (a === undefined)
+        return b;
+    if (b === undefined)
+        return a;
+    return `${a}\n${b}`;
+}
+function mergeStructured(a, b) {
+    if (!a && !b)
+        return undefined;
+    if (!a)
+        return { ...b };
+    if (!b)
+        return { ...a };
+    const out = { ...a };
+    for (const k of Object.keys(b)) {
+        const av = a[k], bv = b[k];
+        if (av && bv &&
+            typeof av === 'object' && typeof bv === 'object' &&
+            !Array.isArray(av) && !Array.isArray(bv)) {
+            out[k] = { ...av, ...bv };
+        }
+        else {
+            out[k] = bv;
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=envelope.js.map

package/dist/futures/latent-state/index.d.ts

@@ -0,0 +1,5 @@
+/** Latent-state envelope — public surface. */
+export type { AgentTransfer, EnvelopeKind, LatentEnvelope, ProvenanceEntry, } from './types.js';
+export { createEnvelope, deserialize, merge, serialize, stableStringify, verifyHash, withProvenance, } from './envelope.js';
+export type { CreateEnvelopeOpts } from './envelope.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/futures/latent-state/index.js

@@ -0,0 +1,3 @@
+/** Latent-state envelope — public surface. */
+export { createEnvelope, deserialize, merge, serialize, stableStringify, verifyHash, withProvenance, } from './envelope.js';
+//# sourceMappingURL=index.js.map

package/dist/futures/latent-state/types.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Latent-state envelope — type definitions.
+ *
+ * Maps onto "Recursive Multi-Agent Systems" (Stanford/UIUC/NVIDIA/MIT,
+ * arXiv:2604.25917). Today most inter-agent handoffs are plain text. As
+ * models gain native structured-state IO, the harness should already be
+ * carrying typed envelopes so the upgrade path is a payload swap, not an
+ * interface change.
+ *
+ * Runtime lives in `envelope.ts`.
+ */
+/** One step in the chain of custody. */
+export interface ProvenanceEntry {
+    step: number;
+    agent: string;
+    ts: string;
+    note?: string;
+}
+/**
+ * Payload discriminator.
+ *  - 'text'       — text only (today's common case)
+ *  - 'structured' — structured payload only (latent-state native)
+ *  - 'mixed'      — both present
+ */
+export type EnvelopeKind = 'text' | 'structured' | 'mixed';
+/**
+ * `contentHash` is sha256 over a canonical JSON serialization of the body
+ * (every field except contentHash itself). Used by `verifyHash` to detect
+ * tampering and by `merge` to derive fresh hashes after combining.
+ */
+export interface LatentEnvelope {
+    version: 1;
+    from: string;
+    to: string;
+    kind: EnvelopeKind;
+    text?: string;
+    structured?: Record<string, unknown>;
+    provenance: ProvenanceEntry[];
+    createdAt: string;
+    contentHash: string;
+}
+/** Wraps an envelope for transport. `ackToken` reserved for future ack flows. */
+export interface AgentTransfer {
+    envelope: LatentEnvelope;
+    ackToken?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/futures/latent-state/types.js

@@ -0,0 +1,13 @@
+/**
+ * Latent-state envelope — type definitions.
+ *
+ * Maps onto "Recursive Multi-Agent Systems" (Stanford/UIUC/NVIDIA/MIT,
+ * arXiv:2604.25917). Today most inter-agent handoffs are plain text. As
+ * models gain native structured-state IO, the harness should already be
+ * carrying typed envelopes so the upgrade path is a payload swap, not an
+ * interface change.
+ *
+ * Runtime lives in `envelope.ts`.
+ */
+export {};
+//# sourceMappingURL=types.js.map