@claude-flow/cli 3.68.0 → 3.70.0

package/dist/src/memory/episode-crud.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Episode get / list / update / delete over agentdb 3.3's ReflexionMemory (ADR-520).
+ *
+ * Episodes are what session ends and `memory distill` record, and what
+ * `agentdb_episode-recall` searches. agentdb 3.3 keeps the id on update and moves the row,
+ * embedding, vector entry and keyword index together; this module only validates, bounds
+ * what goes back over MCP, and feature-detects older agentdb builds.
+ *
+ * @module v3/cli/memory/episode-crud
+ */
+export declare const EPISODE_CRUD_UNAVAILABLE = "Episode get/list/update/delete needs agentdb >= 3.3.0 with ReflexionMemory available.";
+export interface EpisodeView {
+    id: number;
+    sessionId: string;
+    task: string;
+    input?: string;
+    output?: string;
+    critique?: string;
+    reward: number;
+    success: boolean;
+    latencyMs?: number;
+    tokensUsed?: number;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    ts?: number;
+}
+export interface EpisodePatch {
+    task?: string;
+    input?: string | null;
+    output?: string | null;
+    critique?: string | null;
+    reward?: number;
+    success?: boolean;
+    tags?: string[] | null;
+    metadata?: Record<string, unknown> | null;
+}
+export type CrudResult<T> = {
+    success: true;
+} & T | {
+    success: false;
+    error: string;
+};
+/** Strict positive integer id. "12-notes" must never reach a delete as 12. */
+export declare function parseEpisodeId(value: unknown): number | null;
+export declare function bridgeGetEpisode(id: number, dbPath?: string): Promise<CrudResult<{
+    episode: EpisodeView | null;
+}> | null>;
+export declare function bridgeListEpisodes(options: {
+    sessionId?: string;
+    success?: boolean;
+    limit?: number;
+    offset?: number;
+    order?: 'newest' | 'oldest';
+}, dbPath?: string): Promise<CrudResult<{
+    episodes: EpisodeView[];
+    total: number;
+    limit: number;
+    offset: number;
+}> | null>;
+export declare function bridgeUpdateEpisode(id: number, patch: EpisodePatch, options?: {
+    replaceMetadata?: boolean;
+}, dbPath?: string): Promise<CrudResult<{
+    episode: EpisodeView | null;
+    reembedded: boolean;
+    changedFields: string[];
+}> | null>;
+export declare function bridgeDeleteEpisode(id: number, dbPath?: string): Promise<CrudResult<{
+    deleted: boolean;
+}> | null>;
+//# sourceMappingURL=episode-crud.d.ts.map

package/dist/src/memory/episode-crud.js

@@ -0,0 +1,114 @@
+/**
+ * Episode get / list / update / delete over agentdb 3.3's ReflexionMemory (ADR-520).
+ *
+ * Episodes are what session ends and `memory distill` record, and what
+ * `agentdb_episode-recall` searches. agentdb 3.3 keeps the id on update and moves the row,
+ * embedding, vector entry and keyword index together; this module only validates, bounds
+ * what goes back over MCP, and feature-detects older agentdb builds.
+ *
+ * @module v3/cli/memory/episode-crud
+ */
+import { withReflexionController } from './memory-bridge.js';
+const TEXT_OUT_MAX = 4_000;
+const LIST_MAX = 100;
+export const EPISODE_CRUD_UNAVAILABLE = 'Episode get/list/update/delete needs agentdb >= 3.3.0 with ReflexionMemory available.';
+/** Strict positive integer id. "12-notes" must never reach a delete as 12. */
+export function parseEpisodeId(value) {
+    const n = typeof value === 'number' ? value
+        : typeof value === 'string' && /^\d+$/.test(value.trim()) ? Number(value.trim())
+            : NaN;
+    return Number.isSafeInteger(n) && n > 0 ? n : null;
+}
+const clip = (v) => typeof v === 'string' && v.length > 0 ? v.slice(0, TEXT_OUT_MAX) : undefined;
+/** Bound what goes back over MCP and drop the embedding. */
+function view(e) {
+    return {
+        id: Number(e.id),
+        sessionId: String(e.sessionId ?? ''),
+        task: String(e.task ?? '').slice(0, TEXT_OUT_MAX),
+        ...(clip(e.input) !== undefined ? { input: clip(e.input) } : {}),
+        ...(clip(e.output) !== undefined ? { output: clip(e.output) } : {}),
+        ...(clip(e.critique) !== undefined ? { critique: clip(e.critique) } : {}),
+        reward: Number(e.reward ?? 0),
+        success: !!e.success,
+        ...(typeof e.latencyMs === 'number' ? { latencyMs: e.latencyMs } : {}),
+        ...(typeof e.tokensUsed === 'number' ? { tokensUsed: e.tokensUsed } : {}),
+        ...(Array.isArray(e.tags) ? { tags: e.tags.slice(0, 64) } : {}),
+        ...(e.metadata && typeof e.metadata === 'object' ? { metadata: e.metadata } : {}),
+        ...(typeof e.ts === 'number' ? { ts: e.ts } : {}),
+    };
+}
+const supports = (r, method) => typeof r?.[method] === 'function';
+/** agentdb throws ValidationError subclasses for bad input; pass their message through, bounded. */
+function failure(error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return { success: false, error: msg.replace(/\/[^\s:]+\//g, '<path>/').slice(0, 500) };
+}
+export async function bridgeGetEpisode(id, dbPath) {
+    return withReflexionController(dbPath, async (r) => {
+        if (!supports(r, 'getEpisode'))
+            return { success: false, error: EPISODE_CRUD_UNAVAILABLE };
+        try {
+            const e = r.getEpisode(id);
+            return { success: true, episode: e ? view(e) : null };
+        }
+        catch (err) {
+            return failure(err);
+        }
+    });
+}
+export async function bridgeListEpisodes(options, dbPath) {
+    return withReflexionController(dbPath, async (r) => {
+        if (!supports(r, 'listEpisodes'))
+            return { success: false, error: EPISODE_CRUD_UNAVAILABLE };
+        try {
+            const page = r.listEpisodes({ ...options, limit: Math.min(options.limit ?? 20, LIST_MAX) });
+            return {
+                success: true,
+                episodes: page.items.map(view),
+                total: Number(page.total),
+                limit: Number(page.limit),
+                offset: Number(page.offset),
+            };
+        }
+        catch (err) {
+            return failure(err);
+        }
+    });
+}
+export async function bridgeUpdateEpisode(id, patch, options = {}, dbPath) {
+    return withReflexionController(dbPath, async (r) => {
+        if (!supports(r, 'updateEpisode'))
+            return { success: false, error: EPISODE_CRUD_UNAVAILABLE };
+        try {
+            const res = await r.updateEpisode(id, patch, { replaceMetadata: options.replaceMetadata === true });
+            if (!res)
+                return { success: true, episode: null, reembedded: false, changedFields: [] };
+            return {
+                success: true,
+                episode: view(res.episode),
+                reembedded: !!res.reembedded,
+                changedFields: Array.isArray(res.changedFields) ? res.changedFields : [],
+            };
+        }
+        catch (err) {
+            return failure(err);
+        }
+    });
+}
+export async function bridgeDeleteEpisode(id, dbPath) {
+    return withReflexionController(dbPath, async (r) => {
+        // deleteEpisode predates 3.3, but before 3.3 it parsed ids with parseInt and never removed
+        // the vector entry; gate on getEpisode so only the fixed implementation is used.
+        if (!supports(r, 'getEpisode') || !supports(r, 'deleteEpisode')) {
+            return { success: false, error: EPISODE_CRUD_UNAVAILABLE };
+        }
+        try {
+            return { success: true, deleted: (await r.deleteEpisode(id)) === true };
+        }
+        catch (err) {
+            return failure(err);
+        }
+    });
+}
+//# sourceMappingURL=episode-crud.js.map

package/dist/src/memory/ewc-consolidation.d.ts

@@ -125,6 +125,13 @@ export interface EWCStats {
     /** Storage size in bytes */
     storageSizeBytes: number;
 }
+/**
+ * #3475: `CLAUDE_FLOW_FISHER_DECAY` overrides the default Fisher EMA decay
+ * rate. Only a finite number in (0, 1] is honoured; anything else is ignored
+ * and the default stands. An explicit `fisherDecayRate` passed to the
+ * constructor still wins.
+ */
+export declare function fisherDecayRateFromEnv(env?: NodeJS.ProcessEnv): number | undefined;
 /**
  * EWC++ Consolidator
  * Implements Elastic Weight Consolidation with online updates

package/dist/src/memory/ewc-consolidation.js

@@ -44,6 +44,19 @@ const DEFAULT_EWC_CONFIG = {
     onlineMode: true,
     dimensions: 384
 };
+/**
+ * #3475: `CLAUDE_FLOW_FISHER_DECAY` overrides the default Fisher EMA decay
+ * rate. Only a finite number in (0, 1] is honoured; anything else is ignored
+ * and the default stands. An explicit `fisherDecayRate` passed to the
+ * constructor still wins.
+ */
+export function fisherDecayRateFromEnv(env = process.env) {
+    const raw = env.CLAUDE_FLOW_FISHER_DECAY;
+    if (raw === undefined || raw.trim() === '')
+        return undefined;
+    const value = Number(raw);
+    return Number.isFinite(value) && value > 0 && value <= 1 ? value : undefined;
+}
 // ============================================================================
 // EWC Consolidator Class
 // ============================================================================
@@ -60,7 +73,12 @@ export class EWCConsolidator {
     consolidationHistory = [];
     initialized = false;
     constructor(config) {
-        this.config = { ...DEFAULT_EWC_CONFIG, ...config };
+        const envDecay = fisherDecayRateFromEnv();
+        this.config = {
+            ...DEFAULT_EWC_CONFIG,
+            ...(envDecay !== undefined ? { fisherDecayRate: envDecay } : {}),
+            ...config,
+        };
         this.globalFisher = new Array(this.config.dimensions).fill(0);
     }
     /**

package/dist/src/memory/memory-bridge.d.ts

@@ -544,6 +544,11 @@ export declare function bridgeRecallEpisodes(options: EpisodeRecallOptions & {
     hybrid: boolean;
     rerank: boolean;
 } | null>;
+/**
+ * Run `fn` against the ReflexionMemory controller inside one bridge operation, so a shutdown waits
+ * for it (ADR-520). Null when the bridge or the controller is unavailable.
+ */
+export declare function withReflexionController<T>(dbPath: string | undefined, fn: (reflexion: any) => Promise<T>): Promise<T | null>;
 /**
  * Start a session with ReflexionMemory episodic replay.
  * Loads relevant past session patterns for the new session.

package/dist/src/memory/memory-bridge.js

@@ -2956,6 +2956,8 @@ export async function bridgeDeleteCausalNode(options) {
 const EPISODE_TASK_MAX = 4_000;
 const EPISODE_TEXT_MAX = 2_000;
 const EPISODE_RECALL_MAX = 50;
+/** #3908: upper bound on the session-end NightlyLearner sweep. */
+const SESSION_END_CONSOLIDATE_TIMEOUT_MS = 10_000;
 /** Null when the registry has no ReflexionMemory with retrieveRelevant. */
 async function recallEpisodesFrom(registry, options) {
     const reflexion = registry.get('reflexion');
@@ -3010,6 +3012,17 @@ export async function bridgeRecallEpisodes(options) {
         rerank: options.rerank === true,
     };
 }
+/**
+ * Run `fn` against the ReflexionMemory controller inside one bridge operation, so a shutdown waits
+ * for it (ADR-520). Null when the bridge or the controller is unavailable.
+ */
+export async function withReflexionController(dbPath, fn) {
+    if (!operationContext.getStore()?.active)
+        return withBridgeOperation(() => withReflexionController(dbPath, fn));
+    const registry = await getRegistry(dbPath);
+    const reflexion = registry?.get?.('reflexion');
+    return reflexion ? fn(reflexion) : null;
+}
 // ===== Phase 5: ReflexionMemory session lifecycle =====
 /**
  * Start a session with ReflexionMemory episodic replay.
@@ -3138,14 +3151,36 @@ export async function bridgeSessionEnd(options) {
             controller = controller === 'none' ? 'bridge-store' : controller + '+bridge-store';
             persisted = true;
         }
-        // Phase 3: Trigger NightlyLearner consolidation if available
+        // Phase 3: Trigger NightlyLearner consolidation if available.
+        // #3908: neither the MemoryConsolidator wrapper nor AgentDB's NightlyLearner
+        // has `consolidate` — they expose `run`/`runAll` — so probing only for
+        // `consolidate` meant session-end never consolidated. Bounded so a slow
+        // sweep cannot hold session-end open.
         const nightlyLearner = registry.get('nightlyLearner');
-        if (nightlyLearner && typeof nightlyLearner.consolidate === 'function') {
+        const consolidate = nightlyLearner && (typeof nightlyLearner.consolidate === 'function'
+            ? () => nightlyLearner.consolidate({ sessionId: options.sessionId })
+            : typeof nightlyLearner.run === 'function'
+                ? () => nightlyLearner.run()
+                : typeof nightlyLearner.runAll === 'function'
+                    ? () => nightlyLearner.runAll()
+                    : null);
+        if (consolidate) {
+            let timer;
             try {
-                await nightlyLearner.consolidate({ sessionId: options.sessionId });
+                await Promise.race([
+                    Promise.resolve().then(consolidate),
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => reject(new Error('nightlyLearner timeout')), SESSION_END_CONSOLIDATE_TIMEOUT_MS);
+                        timer.unref?.();
+                    }),
+                ]);
                 controller += '+nightlyLearner';
             }
             catch { /* non-fatal */ }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
         }
         return { success: true, controller, persisted, ...(episodeId !== undefined ? { episodeId } : {}) };
     }

package/dist/src/mods/command-registry/schema.d.ts

@@ -388,7 +388,6 @@ export declare const catalogEntrySchema: z.ZodObject<{
     }>, "many">;
     notes: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
-    status: "documentation" | "shipped" | "source-only";
     sources: {
         digest: string;
         sourcePath: string;
@@ -399,6 +398,7 @@ export declare const catalogEntrySchema: z.ZodObject<{
         shippedIn: string[];
         initCategory?: string | undefined;
     }[];
+    status: "documentation" | "shipped" | "source-only";
     divergent: boolean;
     definition: {
         id: string;
@@ -429,7 +429,6 @@ export declare const catalogEntrySchema: z.ZodObject<{
     };
     notes: string[];
 }, {
-    status: "documentation" | "shipped" | "source-only";
     sources: {
         digest: string;
         sourcePath: string;
@@ -440,6 +439,7 @@ export declare const catalogEntrySchema: z.ZodObject<{
         shippedIn: string[];
         initCategory?: string | undefined;
     }[];
+    status: "documentation" | "shipped" | "source-only";
     divergent: boolean;
     definition: {
         id: string;
@@ -654,7 +654,6 @@ export declare const commandCatalogSchema: z.ZodObject<{
         }>, "many">;
         notes: z.ZodArray<z.ZodString, "many">;
     }, "strict", z.ZodTypeAny, {
-        status: "documentation" | "shipped" | "source-only";
         sources: {
             digest: string;
             sourcePath: string;
@@ -665,6 +664,7 @@ export declare const commandCatalogSchema: z.ZodObject<{
             shippedIn: string[];
             initCategory?: string | undefined;
         }[];
+        status: "documentation" | "shipped" | "source-only";
         divergent: boolean;
         definition: {
             id: string;
@@ -695,7 +695,6 @@ export declare const commandCatalogSchema: z.ZodObject<{
         };
         notes: string[];
     }, {
-        status: "documentation" | "shipped" | "source-only";
         sources: {
             digest: string;
             sourcePath: string;
@@ -706,6 +705,7 @@ export declare const commandCatalogSchema: z.ZodObject<{
             shippedIn: string[];
             initCategory?: string | undefined;
         }[];
+        status: "documentation" | "shipped" | "source-only";
         divergent: boolean;
         definition: {
             id: string;
@@ -738,7 +738,6 @@ export declare const commandCatalogSchema: z.ZodObject<{
     }>, "many">;
 }, "strict", z.ZodTypeAny, {
     entries: {
-        status: "documentation" | "shipped" | "source-only";
         sources: {
             digest: string;
             sourcePath: string;
@@ -749,6 +748,7 @@ export declare const commandCatalogSchema: z.ZodObject<{
             shippedIn: string[];
             initCategory?: string | undefined;
         }[];
+        status: "documentation" | "shipped" | "source-only";
         divergent: boolean;
         definition: {
             id: string;
@@ -784,7 +784,6 @@ export declare const commandCatalogSchema: z.ZodObject<{
     sourceDigest: string;
 }, {
     entries: {
-        status: "documentation" | "shipped" | "source-only";
         sources: {
             digest: string;
             sourcePath: string;
@@ -795,6 +794,7 @@ export declare const commandCatalogSchema: z.ZodObject<{
             shippedIn: string[];
             initCategory?: string | undefined;
         }[];
+        status: "documentation" | "shipped" | "source-only";
         divergent: boolean;
         definition: {
             id: string;

package/dist/src/services/anthropic-context-adapter.d.ts

@@ -0,0 +1,81 @@
+/** Fixed-destination, tool-free Messages adapter. Credentials remain in host memory.
+ * No provider fallback, endpoint override, subprocess, tools, retries or logging.
+ */
+import { type GlobalAiBudget } from './global-ai-budget.js';
+import { type ContextAdapter } from './context-delegation.js';
+export interface AnthropicContextPricing {
+    model: string;
+    inputUsdPerMillion: number;
+    outputUsdPerMillion: number;
+    cacheReadUsdPerMillion: number;
+    cacheWrite5mUsdPerMillion: number;
+    cacheWrite1hUsdPerMillion: number;
+    source: string;
+    observedAt: string;
+}
+export interface AnthropicContextAuthorization {
+    action: 'context.read.delegate';
+    endpoints: readonly ['https://api.anthropic.com/v1/messages/count_tokens', 'https://api.anthropic.com/v1/messages'];
+    model: string;
+    requestSha256: string;
+    sourceHashes: ReadonlyArray<Readonly<{
+        path: string;
+        sha256: string;
+    }>>;
+    requestBytes: number;
+    countRequestBytes: number;
+    totalRequestBytes: number;
+    inputTokenCeiling: number;
+    outputTokenCeiling: number;
+    costCeilingUsd: number;
+    concurrency: 1;
+    tools: readonly [];
+}
+export interface AnthropicContextUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadInputTokens: number;
+    cacheCreationInputTokens: number;
+    cacheWrite5mInputTokens: number;
+    cacheWrite1hInputTokens: number;
+}
+export interface AnthropicContextCallReceipt {
+    requestSha256: string;
+    requestedModel: string;
+    actualModel?: string;
+    requestId?: string;
+    stopReason?: string;
+    status: 'succeeded' | 'failed';
+    stage: string;
+    durationMs: number;
+    countedInputTokens?: number;
+    usage?: AnthropicContextUsage;
+    /** Computed from captured usage and supplied prices; never invoice proof. */
+    usagePricedCostUsd?: number;
+    pricing: AnthropicContextPricing;
+}
+export interface AnthropicContextAdapterOptions {
+    apiKey: string;
+    model: string;
+    workspace: string;
+    pricing: AnthropicContextPricing;
+    maxOutputTokens: number;
+    maxCostUsd: number;
+    /** Mandatory host policy gate, with no source content or credential arguments.
+     * Host must retain/reduce its inherited envelope, never construct broader authority.
+     */
+    authorize: (request: Readonly<AnthropicContextAuthorization>, signal: AbortSignal) => Promise<boolean>;
+    /** Trusted runtime port; default is the existing user-global launch fuse. */
+    budget?: Pick<GlobalAiBudget, 'reserve' | 'release' | 'recordQuotaError'> & Partial<Pick<GlobalAiBudget, 'recordUsage'>>;
+    maxResponseBytes?: number;
+    timeoutMs?: number;
+}
+export interface GovernedAnthropicContextAdapter extends ContextAdapter {
+    receipts(): readonly Readonly<AnthropicContextCallReceipt>[];
+}
+/** No inference happens until host authorization and a global launch permit.
+ * Uses token counting before generation, retaining one global slot across both
+ * requests. At most one count request and one generation, never a retry.
+ */
+export declare function createAnthropicContextAdapter(options: AnthropicContextAdapterOptions): GovernedAnthropicContextAdapter;
+//# sourceMappingURL=anthropic-context-adapter.d.ts.map