@vauban-org/agent-sdk 1.0.0 → 1.2.0

package/dist/memory/episodic-rrf.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Episodic memory recall — weighted score combination (cosine + recency + importance).
+ *
+ * Despite the file name (RRF — Reciprocal Rank Fusion), the algorithm used
+ * for CC v3.1 is a **linear combination of normalized components**:
+ *
+ *   score(e) = α · cosine_sim(q, e.embedding)
+ *            + β · exp(-Δt / τ)               // recency decay
+ *            + γ · importance(e)               // [0,1]
+ *
+ *   defaults: α=0.5, β=0.3, γ=0.2, τ=14 days
+ *
+ * This shape was chosen over pure RRF because the three signals are
+ * heterogeneous (similarity, time, salience) and combining them via rank
+ * fusion would erase the magnitude information that callers care about
+ * (e.g. "near-perfect cosine match" vs "loosely related").
+ *
+ * Pluggable scorers — callers provide functions mapping an entry to each
+ * component so the algorithm is decoupled from storage details (embedding
+ * column, importance field name, etc.).
+ *
+ * @see ../ports/brain.ts — EpisodicMemoryEntry
+ * @see ADR-ECO-034 §"AgentPersona via Brain Tier 3 semantic" (companion)
+ * @public
+ */
+import type { EpisodicMemoryEntry } from "../ports/brain.js";
+/** Default weights — sum to 1.0. */
+export declare const DEFAULT_RRF_WEIGHTS: {
+    readonly cosine: 0.5;
+    readonly recency: 0.3;
+    readonly importance: 0.2;
+};
+/** Default recency half-life (14 days in ms). */
+export declare const DEFAULT_RECENCY_HALFLIFE_MS: number;
+export interface RrfWeights {
+    cosine: number;
+    recency: number;
+    importance: number;
+}
+export interface RrfOptions {
+    weights?: Partial<RrfWeights>;
+    /** Half-life for recency decay (default: 14 days). */
+    recencyHalflifeMs?: number;
+    /** Cap on returned entries (default: unbounded). */
+    topK?: number;
+    /** Override "now" for deterministic tests. */
+    now?: () => number;
+}
+export interface ScoreComponents {
+    cosine: number;
+    recency: number;
+    importance: number;
+}
+export interface ScoredEntry<T> {
+    entry: T;
+    score: number;
+    components: ScoreComponents;
+}
+export interface RrfScorers<T> {
+    /** Cosine similarity ∈ [-1, 1] — non-finite values clamped to 0. */
+    cosine: (entry: T) => number;
+    /** Timestamp (ms epoch) used for recency decay. Negative → drop the entry. */
+    timestamp: (entry: T) => number;
+    /** Salience ∈ [0, 1]. Out-of-range values clamped. */
+    importance: (entry: T) => number;
+}
+/**
+ * Cosine similarity between two equal-length numeric vectors.
+ *
+ * Returns 0 if either vector is empty / zero-norm / mismatched length —
+ * never throws. This makes the function safe to compose into scorers that
+ * may receive partial entries.
+ */
+export declare function cosineSimilarity(a: number[], b: number[]): number;
+/**
+ * Recency score in [0, 1]: exp(-ln(2) · Δt / halflife).
+ *   - 1.0 at Δt = 0
+ *   - 0.5 at Δt = halflife
+ *   - approaches 0 as Δt → ∞
+ *
+ * `nowMs` and `timestampMs` are epoch ms. Future timestamps (Δt < 0) clamp
+ * to 1.0 (treated as "right now").
+ */
+export declare function recencyScore(nowMs: number, timestampMs: number, halflifeMs: number): number;
+/**
+ * Score a batch of entries via the weighted combination. The result is sorted
+ * by descending score and trimmed to `topK` when set.
+ *
+ * Negative timestamps (per `scorers.timestamp`) cause the entry to be dropped
+ * entirely — this is the cheap way for a scorer to signal "skip" (e.g. row
+ * lacks the field).
+ */
+export declare function scoreEntries<T>(entries: T[], scorers: RrfScorers<T>, opts?: RrfOptions): ScoredEntry<T>[];
+/**
+ * The agent-sdk EpisodicMemoryEntry does NOT carry an embedding column —
+ * embeddings live in the storage layer (Postgres pgvector). To enable
+ * pluggable cosine scoring, the caller may attach an embedding via the
+ * `embedding` field on `metadata`, or supply a custom resolver.
+ */
+export type EpisodicCosineFn = (entry: EpisodicMemoryEntry) => number;
+export interface RecallRrfOptions extends RrfOptions {
+    /**
+     * Cosine scorer — defaults to 0 (no embedding). Provide when you have a
+     * pre-computed (entry × query) similarity for each entry.
+     */
+    cosine?: EpisodicCosineFn;
+}
+/**
+ * Rank EpisodicMemoryEntry[] by weighted score. Convenience over scoreEntries
+ * with the standard projection (timestamp = entry.timestamp,
+ * importance = metadata.importance ?? 0.5).
+ */
+export declare function recallEpisodicRrf(entries: EpisodicMemoryEntry[], opts?: RecallRrfOptions): ScoredEntry<EpisodicMemoryEntry>[];
+//# sourceMappingURL=episodic-rrf.d.ts.map

package/dist/memory/episodic-rrf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"episodic-rrf.d.ts","sourceRoot":"","sources":["../../src/memory/episodic-rrf.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAE7D,oCAAoC;AACpC,eAAO,MAAM,mBAAmB;;;;CAItB,CAAC;AAEX,iDAAiD;AACjD,eAAO,MAAM,2BAA2B,QAA2B,CAAC;AAEpE,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAC9B,sDAAsD;IACtD,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,oDAAoD;IACpD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,8CAA8C;IAC9C,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B,KAAK,EAAE,CAAC,CAAC;IACT,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,eAAe,CAAC;CAC7B;AAED,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,oEAAoE;IACpE,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC;IAC7B,8EAA8E;IAC9E,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC;IAChC,sDAAsD;IACtD,UAAU,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC;CAClC;AAID;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAcjE;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,GACjB,MAAM,CAIR;AAkBD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,OAAO,EAAE,CAAC,EAAE,EACZ,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,EACtB,IAAI,GAAE,UAAe,GACpB,WAAW,CAAC,CAAC,CAAC,EAAE,CA+BlB;AAID;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,mBAAmB,KAAK,MAAM,CAAC;AAKtE,MAAM,WAAW,gBAAiB,SAAQ,UAAU;IAClD;;;OAGG;IACH,MAAM,CAAC,EAAE,gBAAgB,CAAC;CAC3B;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,mBAAmB,EAAE,EAC9B,IAAI,GAAE,gBAAqB,GAC1B,WAAW,CAAC,mBAAmB,CAAC,EAAE,CAcpC"}

package/dist/memory/episodic-rrf.js

@@ -0,0 +1,148 @@
+/**
+ * Episodic memory recall — weighted score combination (cosine + recency + importance).
+ *
+ * Despite the file name (RRF — Reciprocal Rank Fusion), the algorithm used
+ * for CC v3.1 is a **linear combination of normalized components**:
+ *
+ *   score(e) = α · cosine_sim(q, e.embedding)
+ *            + β · exp(-Δt / τ)               // recency decay
+ *            + γ · importance(e)               // [0,1]
+ *
+ *   defaults: α=0.5, β=0.3, γ=0.2, τ=14 days
+ *
+ * This shape was chosen over pure RRF because the three signals are
+ * heterogeneous (similarity, time, salience) and combining them via rank
+ * fusion would erase the magnitude information that callers care about
+ * (e.g. "near-perfect cosine match" vs "loosely related").
+ *
+ * Pluggable scorers — callers provide functions mapping an entry to each
+ * component so the algorithm is decoupled from storage details (embedding
+ * column, importance field name, etc.).
+ *
+ * @see ../ports/brain.ts — EpisodicMemoryEntry
+ * @see ADR-ECO-034 §"AgentPersona via Brain Tier 3 semantic" (companion)
+ * @public
+ */
+/** Default weights — sum to 1.0. */
+export const DEFAULT_RRF_WEIGHTS = {
+    cosine: 0.5,
+    recency: 0.3,
+    importance: 0.2,
+};
+/** Default recency half-life (14 days in ms). */
+export const DEFAULT_RECENCY_HALFLIFE_MS = 14 * 24 * 60 * 60 * 1000;
+// ─── Pure helpers ─────────────────────────────────────────────────────────────
+/**
+ * Cosine similarity between two equal-length numeric vectors.
+ *
+ * Returns 0 if either vector is empty / zero-norm / mismatched length —
+ * never throws. This makes the function safe to compose into scorers that
+ * may receive partial entries.
+ */
+export function cosineSimilarity(a, b) {
+    if (a.length === 0 || a.length !== b.length)
+        return 0;
+    let dot = 0;
+    let na = 0;
+    let nb = 0;
+    for (let i = 0; i < a.length; i++) {
+        const ai = a[i];
+        const bi = b[i];
+        dot += ai * bi;
+        na += ai * ai;
+        nb += bi * bi;
+    }
+    if (na === 0 || nb === 0)
+        return 0;
+    return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+/**
+ * Recency score in [0, 1]: exp(-ln(2) · Δt / halflife).
+ *   - 1.0 at Δt = 0
+ *   - 0.5 at Δt = halflife
+ *   - approaches 0 as Δt → ∞
+ *
+ * `nowMs` and `timestampMs` are epoch ms. Future timestamps (Δt < 0) clamp
+ * to 1.0 (treated as "right now").
+ */
+export function recencyScore(nowMs, timestampMs, halflifeMs) {
+    if (halflifeMs <= 0)
+        return 0;
+    const dt = Math.max(0, nowMs - timestampMs);
+    return Math.exp((-Math.LN2 * dt) / halflifeMs);
+}
+/** Clamp to [0, 1]; NaN / non-finite → 0. */
+function clamp01(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    if (value < 0)
+        return 0;
+    if (value > 1)
+        return 1;
+    return value;
+}
+/** Clamp cosine output (−1..1) to ≥0 to avoid negative contributions. */
+function clampCosineToPos(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return value < 0 ? 0 : value;
+}
+// ─── Generic scorer ───────────────────────────────────────────────────────────
+/**
+ * Score a batch of entries via the weighted combination. The result is sorted
+ * by descending score and trimmed to `topK` when set.
+ *
+ * Negative timestamps (per `scorers.timestamp`) cause the entry to be dropped
+ * entirely — this is the cheap way for a scorer to signal "skip" (e.g. row
+ * lacks the field).
+ */
+export function scoreEntries(entries, scorers, opts = {}) {
+    const weights = {
+        cosine: opts.weights?.cosine ?? DEFAULT_RRF_WEIGHTS.cosine,
+        recency: opts.weights?.recency ?? DEFAULT_RRF_WEIGHTS.recency,
+        importance: opts.weights?.importance ?? DEFAULT_RRF_WEIGHTS.importance,
+    };
+    const halflifeMs = opts.recencyHalflifeMs ?? DEFAULT_RECENCY_HALFLIFE_MS;
+    const nowMs = (opts.now ?? Date.now)();
+    const scored = [];
+    for (const entry of entries) {
+        const ts = scorers.timestamp(entry);
+        if (ts < 0)
+            continue;
+        const cosine = clampCosineToPos(scorers.cosine(entry));
+        const recency = recencyScore(nowMs, ts, halflifeMs);
+        const importance = clamp01(scorers.importance(entry));
+        const score = weights.cosine * cosine +
+            weights.recency * recency +
+            weights.importance * importance;
+        scored.push({
+            entry,
+            score,
+            components: { cosine, recency, importance },
+        });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    if (opts.topK !== undefined && opts.topK >= 0) {
+        return scored.slice(0, opts.topK);
+    }
+    return scored;
+}
+/** Default cosine: 0 (no embedding available — relies on recency + importance only). */
+const ZERO_COSINE = () => 0;
+/**
+ * Rank EpisodicMemoryEntry[] by weighted score. Convenience over scoreEntries
+ * with the standard projection (timestamp = entry.timestamp,
+ * importance = metadata.importance ?? 0.5).
+ */
+export function recallEpisodicRrf(entries, opts = {}) {
+    const cosineFn = opts.cosine ?? ZERO_COSINE;
+    return scoreEntries(entries, {
+        cosine: cosineFn,
+        timestamp: (e) => e.timestamp,
+        importance: (e) => {
+            const raw = e.metadata?.importance ?? 0.5;
+            return typeof raw === "number" ? raw : 0.5;
+        },
+    }, opts);
+}
+//# sourceMappingURL=episodic-rrf.js.map

package/dist/memory/episodic-rrf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"episodic-rrf.js","sourceRoot":"","sources":["../../src/memory/episodic-rrf.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,oCAAoC;AACpC,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,MAAM,EAAE,GAAG;IACX,OAAO,EAAE,GAAG;IACZ,UAAU,EAAE,GAAG;CACP,CAAC;AAEX,iDAAiD;AACjD,MAAM,CAAC,MAAM,2BAA2B,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAuCpE,iFAAiF;AAEjF;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAAC,CAAW,EAAE,CAAW;IACvD,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM;QAAE,OAAO,CAAC,CAAC;IACtD,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,IAAI,EAAE,GAAG,CAAC,CAAC;IACX,IAAI,EAAE,GAAG,CAAC,CAAC;IACX,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAClC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAE,CAAC;QACjB,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAE,CAAC;QACjB,GAAG,IAAI,EAAE,GAAG,EAAE,CAAC;QACf,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;QACd,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;IAChB,CAAC;IACD,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IACnC,OAAO,GAAG,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,YAAY,CAC1B,KAAa,EACb,WAAmB,EACnB,UAAkB;IAElB,IAAI,UAAU,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC;IAC9B,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,WAAW,CAAC,CAAC;IAC5C,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC;AACjD,CAAC;AAED,6CAA6C;AAC7C,SAAS,OAAO,CAAC,KAAa;IAC5B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IACtC,IAAI,KAAK,GAAG,CAAC;QAAE,OAAO,CAAC,CAAC;IACxB,IAAI,KAAK,GAAG,CAAC;QAAE,OAAO,CAAC,CAAC;IACxB,OAAO,KAAK,CAAC;AACf,CAAC;AAED,yEAAyE;AACzE,SAAS,gBAAgB,CAAC,KAAa;IACrC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IACtC,OAAO,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;AAC/B,CAAC;AAED,iFAAiF;AAEjF;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAC1B,OAAY,EACZ,OAAsB,EACtB,OAAmB,EAAE;IAErB,MAAM,OAAO,GAAe;QAC1B,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,IAAI,mBAAmB,CAAC,MAAM;QAC1D,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,IAAI,mBAAmB,CAAC,OAAO;QAC7D,UAAU,EAAE,IAAI,CAAC,OAAO,EAAE,UAAU,IAAI,mBAAmB,CAAC,UAAU;KACvE,CAAC;IACF,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,IAAI,2BAA2B,CAAC;IACzE,MAAM,KAAK,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;IAEvC,MAAM,MAAM,GAAqB,EAAE,CAAC;IACpC,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,MAAM,EAAE,GAAG,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACpC,IAAI,EAAE,GAAG,CAAC;YAAE,SAAS;QACrB,MAAM,MAAM,GAAG,gBAAgB,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QACvD,MAAM,OAAO,GAAG,YAAY,CAAC,KAAK,EAAE,EAAE,EAAE,UAAU,CAAC,CAAC;QACpD,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC;QACtD,MAAM,KAAK,GACT,OAAO,CAAC,MAAM,GAAG,MAAM;YACvB,OAAO,CAAC,OAAO,GAAG,OAAO;YACzB,OAAO,CAAC,UAAU,GAAG,UAAU,CAAC;QAClC,MAAM,CAAC,IAAI,CAAC;YACV,KAAK;YACL,KAAK;YACL,UAAU,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE;SAC5C,CAAC,CAAC;IACL,CAAC;IACD,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;IACzC,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC;QAC9C,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAYD,wFAAwF;AACxF,MAAM,WAAW,GAAqB,GAAG,EAAE,CAAC,CAAC,CAAC;AAU9C;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAC/B,OAA8B,EAC9B,OAAyB,EAAE;IAE3B,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,IAAI,WAAW,CAAC;IAC5C,OAAO,YAAY,CACjB,OAAO,EACP;QACE,MAAM,EAAE,QAAQ;QAChB,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS;QAC7B,UAAU,EAAE,CAAC,CAAC,EAAE,EAAE;YAChB,MAAM,GAAG,GAAI,CAAC,CAAC,QAAQ,EAAE,UAAsB,IAAI,GAAG,CAAC;YACvD,OAAO,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;QAC7C,CAAC;KACF,EACD,IAAI,CACL,CAAC;AACJ,CAAC"}

package/dist/mesh/attenuation.d.ts

@@ -0,0 +1,78 @@
+/**
+ * src/mesh/attenuation.ts
+ *
+ * Biscuit-style capability attenuation for mesh.delegate().
+ *
+ * @experimental — sprint-585. Public API may change before v1.x freeze.
+ *
+ * Implements capability INTERSECTION (child ⊆ parent) without the actual
+ * Biscuit token format — keeps the SDK dependency-free. Production deployments
+ * should swap `buildToken` / `parseToken` for a real Biscuit issuer in CC.
+ *
+ * Invariants:
+ *  - Child actions = INTERSECTION(parent.actions, requested.actions)
+ *  - Child budget  = MIN(parent.budgetEur, requested.budgetEur)
+ *  - Child expiry  = MIN(parent.expiresAt, requested.expiresAt) when both present
+ *  - Wildcard support: "*" or "ns:*" in parent grants any matching action.
+ *
+ * No `any` — strict types per craft-standards.
+ */
+/**
+ * MeshCapabilityScope — bounded capability declaration for mesh dispatch.
+ *
+ * Renamed from `CapabilityScope` to avoid clash with `ports/delegation.ts`
+ * which models a different (DelegationClaim) shape.
+ */
+export interface MeshCapabilityScope {
+    /** Actions permitted, e.g. ["brain:read", "vault:read", "hitl:trigger"]. */
+    readonly actions: ReadonlyArray<string>;
+    /** Max EUR the holder may spend under this scope. */
+    readonly budgetEur: number;
+    /** Hard expiry — past this date, scope MUST be rejected by callers. */
+    readonly expiresAt?: Date;
+}
+/** Backwards-compatible alias for the spec name `CapabilityScope`. */
+export type CapabilityScope = MeshCapabilityScope;
+/**
+ * AttenuatedToken — opaque transport for a scope across an agent boundary.
+ *
+ * Phase MVP : plain object (no signature). Phase 2+ : swap with Biscuit token
+ * (the encoded `token` field becomes the Biscuit hex / base64 form).
+ */
+export interface AttenuatedToken {
+    /** Allowed actions (post-attenuation). */
+    readonly scope: ReadonlyArray<string>;
+    /** Remaining EUR allowance. */
+    readonly budgetEur: number;
+    /** Parent agent identifier — caller of the delegation step. */
+    readonly parentId: string;
+    /** Optional expiry, ISO 8601 — propagated from MeshCapabilityScope.expiresAt. */
+    readonly expiresAt?: string;
+}
+/**
+ * Attenuate a parent scope by a requested scope.
+ *
+ * Returns a NEW scope (immutable input semantics).
+ * Guarantees `child ⊆ parent` (capability intersection invariant).
+ */
+export declare function attenuateScope(parent: MeshCapabilityScope, requested: MeshCapabilityScope): MeshCapabilityScope;
+/**
+ * Check whether a scope permits a specific action.
+ * Supports wildcards (`"*"`, `"ns:*"`). Returns false if scope is expired.
+ */
+export declare function scopeAllows(scope: MeshCapabilityScope, action: string): boolean;
+/**
+ * Encode a scope as an opaque token bound to a parent identifier.
+ *
+ * Phase MVP : plain structural copy. Phase 2+ : replace with Biscuit-signed token
+ * (the `parentId` becomes the issuer public key, `scope`/`budgetEur` become
+ * Biscuit facts, `expiresAt` becomes a Biscuit check).
+ */
+export declare function buildToken(scope: MeshCapabilityScope, parentId: string): AttenuatedToken;
+/**
+ * Decode a token back to a MeshCapabilityScope.
+ *
+ * Inverse of `buildToken` modulo identity loss (parentId not part of scope).
+ */
+export declare function parseToken(token: AttenuatedToken): MeshCapabilityScope;
+//# sourceMappingURL=attenuation.d.ts.map

package/dist/mesh/attenuation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attenuation.d.ts","sourceRoot":"","sources":["../../src/mesh/attenuation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACxC,qDAAqD;IACrD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,uEAAuE;IACvE,QAAQ,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC;CAC3B;AAED,sEAAsE;AACtE,MAAM,MAAM,eAAe,GAAG,mBAAmB,CAAC;AAElD;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,0CAA0C;IAC1C,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC,+BAA+B;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,+DAA+D;IAC/D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,iFAAiF;IACjF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AA6CD;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,mBAAmB,EAC3B,SAAS,EAAE,mBAAmB,GAC7B,mBAAmB,CA8BrB;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAM/E;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,GAAG,eAAe,CAaxF;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,mBAAmB,CAStE"}

package/dist/mesh/attenuation.js

@@ -0,0 +1,141 @@
+/**
+ * src/mesh/attenuation.ts
+ *
+ * Biscuit-style capability attenuation for mesh.delegate().
+ *
+ * @experimental — sprint-585. Public API may change before v1.x freeze.
+ *
+ * Implements capability INTERSECTION (child ⊆ parent) without the actual
+ * Biscuit token format — keeps the SDK dependency-free. Production deployments
+ * should swap `buildToken` / `parseToken` for a real Biscuit issuer in CC.
+ *
+ * Invariants:
+ *  - Child actions = INTERSECTION(parent.actions, requested.actions)
+ *  - Child budget  = MIN(parent.budgetEur, requested.budgetEur)
+ *  - Child expiry  = MIN(parent.expiresAt, requested.expiresAt) when both present
+ *  - Wildcard support: "*" or "ns:*" in parent grants any matching action.
+ *
+ * No `any` — strict types per craft-standards.
+ */
+// ─── Wildcard match ──────────────────────────────────────────────────────────
+/**
+ * Match an action against a parent permission entry.
+ *
+ *  - Exact match (case-sensitive).
+ *  - `"*"` grants everything.
+ *  - `"ns:*"` grants any action whose namespace prefix matches `ns:`.
+ */
+function permissionMatches(parentPerm, requested) {
+    if (parentPerm === "*" || parentPerm === requested)
+        return true;
+    if (parentPerm.endsWith(":*")) {
+        const prefix = parentPerm.slice(0, -1); // keep trailing colon
+        return requested.startsWith(prefix);
+    }
+    return false;
+}
+/**
+ * Intersect a parent action set with a requested set.
+ * Output: only requested actions that the parent allows (preserving order).
+ */
+function intersectActions(parent, requested) {
+    const out = [];
+    const seen = new Set();
+    for (const req of requested) {
+        if (seen.has(req))
+            continue;
+        for (const p of parent) {
+            if (permissionMatches(p, req)) {
+                out.push(req);
+                seen.add(req);
+                break;
+            }
+        }
+    }
+    return out;
+}
+// ─── Public API ──────────────────────────────────────────────────────────────
+/**
+ * Attenuate a parent scope by a requested scope.
+ *
+ * Returns a NEW scope (immutable input semantics).
+ * Guarantees `child ⊆ parent` (capability intersection invariant).
+ */
+export function attenuateScope(parent, requested) {
+    if (!Number.isFinite(parent.budgetEur) || parent.budgetEur < 0) {
+        throw new RangeError(`attenuateScope: parent.budgetEur must be ≥ 0, got ${parent.budgetEur}`);
+    }
+    if (!Number.isFinite(requested.budgetEur) || requested.budgetEur < 0) {
+        throw new RangeError(`attenuateScope: requested.budgetEur must be ≥ 0, got ${requested.budgetEur}`);
+    }
+    const childActions = intersectActions(parent.actions, requested.actions);
+    const childBudget = Math.min(parent.budgetEur, requested.budgetEur);
+    let childExpiresAt;
+    if (parent.expiresAt && requested.expiresAt) {
+        childExpiresAt = new Date(Math.min(parent.expiresAt.getTime(), requested.expiresAt.getTime()));
+    }
+    else if (parent.expiresAt) {
+        childExpiresAt = new Date(parent.expiresAt.getTime());
+    }
+    else if (requested.expiresAt) {
+        childExpiresAt = new Date(requested.expiresAt.getTime());
+    }
+    const out = childExpiresAt
+        ? {
+            actions: childActions,
+            budgetEur: childBudget,
+            expiresAt: childExpiresAt,
+        }
+        : { actions: childActions, budgetEur: childBudget };
+    return out;
+}
+/**
+ * Check whether a scope permits a specific action.
+ * Supports wildcards (`"*"`, `"ns:*"`). Returns false if scope is expired.
+ */
+export function scopeAllows(scope, action) {
+    if (scope.expiresAt && scope.expiresAt.getTime() <= Date.now())
+        return false;
+    for (const perm of scope.actions) {
+        if (permissionMatches(perm, action))
+            return true;
+    }
+    return false;
+}
+/**
+ * Encode a scope as an opaque token bound to a parent identifier.
+ *
+ * Phase MVP : plain structural copy. Phase 2+ : replace with Biscuit-signed token
+ * (the `parentId` becomes the issuer public key, `scope`/`budgetEur` become
+ * Biscuit facts, `expiresAt` becomes a Biscuit check).
+ */
+export function buildToken(scope, parentId) {
+    if (!parentId || typeof parentId !== "string") {
+        throw new TypeError("buildToken: parentId must be a non-empty string");
+    }
+    const out = scope.expiresAt
+        ? {
+            scope: [...scope.actions],
+            budgetEur: scope.budgetEur,
+            parentId,
+            expiresAt: scope.expiresAt.toISOString(),
+        }
+        : { scope: [...scope.actions], budgetEur: scope.budgetEur, parentId };
+    return out;
+}
+/**
+ * Decode a token back to a MeshCapabilityScope.
+ *
+ * Inverse of `buildToken` modulo identity loss (parentId not part of scope).
+ */
+export function parseToken(token) {
+    const out = token.expiresAt
+        ? {
+            actions: [...token.scope],
+            budgetEur: token.budgetEur,
+            expiresAt: new Date(token.expiresAt),
+        }
+        : { actions: [...token.scope], budgetEur: token.budgetEur };
+    return out;
+}
+//# sourceMappingURL=attenuation.js.map

package/dist/mesh/attenuation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attenuation.js","sourceRoot":"","sources":["../../src/mesh/attenuation.ts"],"names":[],"mappings":"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"}

package/dist/mesh/delegate.d.ts

@@ -0,0 +1,96 @@
+/**
+ * src/mesh/delegate.ts
+ *
+ * `mesh.delegate()` — intent-based dispatch to the best available agent.
+ *
+ * @experimental — sprint-585. Public API may change before v1.x freeze.
+ *
+ * Replaces manual `withCompute()` boilerplate with a one-liner:
+ *
+ *     const r = await meshDelegate({ need: "summarize the spec" }, dispatcher);
+ *
+ * Responsibilities:
+ *   1. Classify need → AgentKind (via dispatcher.classify or injected hint).
+ *   2. Apply capability attenuation if a parent token is present.
+ *   3. Forward to dispatcher with budget/deadline guards.
+ *   4. Build a delegation chain link for audit.
+ *
+ * Streaming (`onChunk`) is a best-effort surface — the dispatcher must opt-in
+ * by exposing a `dispatchStream` (not part of base contract). When unavailable,
+ * the final result is delivered as a single chunk after completion.
+ */
+import { type AttenuatedToken } from "./attenuation.js";
+import { DefaultMeshDispatcher, type MeshDispatcher } from "./dispatcher.js";
+import type { DelegationLink, MeshAgentKind } from "./types.js";
+export interface DelegateChunk {
+    readonly text: string;
+    readonly done: boolean;
+    readonly agentKind?: MeshAgentKind;
+}
+export interface DelegateOptions {
+    /** Natural language description of the need. */
+    readonly need: string;
+    /** Optional structured or free-form context. Serialized to JSON if object. */
+    readonly context?: string | Record<string, unknown>;
+    /** Caller-requested capabilities (subject to attenuation if parentToken present). */
+    readonly capabilities?: ReadonlyArray<string>;
+    /** Wall-clock budget in ms. Default 30 000. */
+    readonly deadline_ms?: number;
+    /** Cost cap in EUR. Default 0.01. */
+    readonly max_cost_eur?: number;
+    /** Parent token — when present, child scope = parent ∩ requested capabilities. */
+    readonly parentToken?: AttenuatedToken;
+    /** Optional streaming callback. */
+    readonly onChunk?: (chunk: DelegateChunk) => void;
+    /** Optional pre-resolved kind — skips classifier. */
+    readonly kind?: MeshAgentKind;
+    /** Stable child agent identifier (for delegation chain audit). Default: random. */
+    readonly childId?: string;
+    /** MCP tool name (only when kind === "mcp-tool"). */
+    readonly toolName?: string;
+    /** MCP tool args (only when kind === "mcp-tool"). */
+    readonly toolArgs?: unknown;
+}
+export interface DelegateResult<T = string> {
+    readonly output: T;
+    readonly agentKind: MeshAgentKind;
+    readonly delegationChain: ReadonlyArray<DelegationLink>;
+    readonly costEur: number;
+    readonly durationMs: number;
+    readonly truncated: boolean;
+    /** Token issued to the child — empty when no parentToken given. */
+    readonly childToken?: AttenuatedToken;
+}
+export declare class DelegateAttenuationError extends Error {
+    readonly name = "DelegateAttenuationError";
+}
+/**
+ * Delegate a need to the best available agent.
+ *
+ * Routing priority (when `kind` not pre-set):
+ *  1. Dispatcher's `classify(need)` hook if present.
+ *  2. Heuristic — see `defaultClassifier`.
+ *
+ * Capability attenuation:
+ *  - If `parentToken` is provided, child scope = parent ∩ requested.
+ *  - Empty intersection raises {@link DelegateAttenuationError}.
+ *
+ * Budget guards:
+ *  - When `parentToken.budgetEur < max_cost_eur`, the effective max is parent's.
+ *  - Negative budget or deadline → RangeError.
+ */
+export declare function meshDelegate<T = string>(options: DelegateOptions, dispatcher: MeshDispatcher): Promise<DelegateResult<T>>;
+/**
+ * Factory variant — binds a dispatcher so callers can call `delegate(opts)`
+ * without re-passing the dispatcher every time.
+ *
+ * Useful for DI in long-lived services.
+ */
+export declare function createMeshDelegate(dispatcher: MeshDispatcher): <T = string>(options: DelegateOptions) => Promise<DelegateResult<T>>;
+/**
+ * Re-export DefaultMeshDispatcher as a convenience so callers can do:
+ *
+ *     import { meshDelegate, DefaultMeshDispatcher } from "@vauban-org/agent-sdk";
+ */
+export { DefaultMeshDispatcher };
+//# sourceMappingURL=delegate.d.ts.map

package/dist/mesh/delegate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegate.d.ts","sourceRoot":"","sources":["../../src/mesh/delegate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EACL,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,qBAAqB,EAAuB,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAClG,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAIhE,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,SAAS,CAAC,EAAE,aAAa,CAAC;CACpC;AAED,MAAM,WAAW,eAAe;IAC9B,gDAAgD;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpD,qFAAqF;IACrF,QAAQ,CAAC,YAAY,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9C,+CAA+C;IAC/C,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,qCAAqC;IACrC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,kFAAkF;IAClF,QAAQ,CAAC,WAAW,CAAC,EAAE,eAAe,CAAC;IACvC,mCAAmC;IACnC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;IAClD,qDAAqD;IACrD,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC;IAC9B,mFAAmF;IACnF,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,qDAAqD;IACrD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,qDAAqD;IACrD,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,cAAc,CAAC,CAAC,GAAG,MAAM;IACxC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IACnB,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;IAClC,QAAQ,CAAC,eAAe,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;IACxD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,mEAAmE;IACnE,QAAQ,CAAC,UAAU,CAAC,EAAE,eAAe,CAAC;CACvC;AA2DD,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,SAAkB,IAAI,8BAA8B;CACrD;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,YAAY,CAAC,CAAC,GAAG,MAAM,EAC3C,OAAO,EAAE,eAAe,EACxB,UAAU,EAAE,cAAc,GACzB,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CA8E5B;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,cAAc,GACzB,CAAC,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAEtE;AAED;;;;GAIG;AACH,OAAO,EAAE,qBAAqB,EAAE,CAAC"}