claude-flow 3.32.2 → 3.32.8

package/v3/@claude-flow/cli/dist/src/proxy/paths.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Filesystem layout for the managed meta-proxy binary (ADR-307), all under
+ * the same `~/.ruflo` state dir every other funnel/proxy/auth file uses
+ * (src/funnel/state.ts's `funnelStateDir()` — respects RUFLO_STATE_DIR for
+ * tests). Centralized here so doctor.ts, install.ts, and lifecycle.ts share
+ * one definition instead of three copies drifting apart.
+ */
+export declare function proxyBinaryPath(): string;
+export declare function proxyPidFilePath(): string;
+export declare function proxyLockFilePath(): string;
+export declare function proxyLogFilePath(): string;
+export declare function proxyInstallManifestPath(): string;
+export declare function proxyConfigPath(): string;
+export declare function proxyTokenPath(): string;
+export declare function proxyInjectedTokenPath(): string;
+export interface InstallManifest {
+    version: string;
+    sha256: string;
+    verifiedAt: string;
+    pubkeyFingerprint: string;
+}
+/**
+ * True if `bind` (a `host:port` string from proxy-config.toml) targets a
+ * loopback address — decides whether the non-loopback exposure warning
+ * fires (ADR-307). Recognizes the whole IPv4 127.0.0.0/8 block, IPv6 `::1`,
+ * IPv4-mapped IPv6 loopback, and the `localhost` hostname.
+ *
+ * A plain `bind.startsWith('127.0.0.1')` check (the obvious first draft)
+ * misclassifies `[::1]:port` as non-loopback — a real bug meta-proxy's own
+ * Rust `is_loopback_bind` fixed for the identical reason; this mirrors that
+ * fix rather than repeating the mistake on the TypeScript side.
+ */
+export declare function isLoopbackBind(bind: string): boolean;
+//# sourceMappingURL=paths.d.ts.map

package/v3/@claude-flow/cli/dist/src/proxy/paths.js

@@ -0,0 +1,70 @@
+/**
+ * Filesystem layout for the managed meta-proxy binary (ADR-307), all under
+ * the same `~/.ruflo` state dir every other funnel/proxy/auth file uses
+ * (src/funnel/state.ts's `funnelStateDir()` — respects RUFLO_STATE_DIR for
+ * tests). Centralized here so doctor.ts, install.ts, and lifecycle.ts share
+ * one definition instead of three copies drifting apart.
+ */
+import { join } from 'node:path';
+import { funnelStateDir } from '../funnel/index.js';
+const BINARY_NAME = process.platform === 'win32' ? 'meta-proxy.exe' : 'meta-proxy';
+export function proxyBinaryPath() {
+    return join(funnelStateDir(), 'bin', BINARY_NAME);
+}
+export function proxyPidFilePath() {
+    return join(funnelStateDir(), 'proxy.pid');
+}
+export function proxyLockFilePath() {
+    return join(funnelStateDir(), 'proxy.lock');
+}
+export function proxyLogFilePath() {
+    return join(funnelStateDir(), 'proxy.log');
+}
+export function proxyInstallManifestPath() {
+    return join(funnelStateDir(), 'proxy', 'install-manifest.json');
+}
+export function proxyConfigPath() {
+    return join(funnelStateDir(), 'proxy-config.toml');
+}
+export function proxyTokenPath() {
+    return join(funnelStateDir(), 'proxy-token');
+}
+export function proxyInjectedTokenPath() {
+    return join(funnelStateDir(), 'proxy-injected-token.json');
+}
+/**
+ * True if `bind` (a `host:port` string from proxy-config.toml) targets a
+ * loopback address — decides whether the non-loopback exposure warning
+ * fires (ADR-307). Recognizes the whole IPv4 127.0.0.0/8 block, IPv6 `::1`,
+ * IPv4-mapped IPv6 loopback, and the `localhost` hostname.
+ *
+ * A plain `bind.startsWith('127.0.0.1')` check (the obvious first draft)
+ * misclassifies `[::1]:port` as non-loopback — a real bug meta-proxy's own
+ * Rust `is_loopback_bind` fixed for the identical reason; this mirrors that
+ * fix rather than repeating the mistake on the TypeScript side.
+ */
+export function isLoopbackBind(bind) {
+    const hostPart = (host) => {
+        const stripped = host.replace(/^\[/, '').replace(/\]$/, '');
+        if (stripped.toLowerCase() === 'localhost')
+            return true;
+        if (/^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(stripped))
+            return true; // 127.0.0.0/8
+        if (stripped === '::1')
+            return true;
+        if (/^::ffff:127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/i.test(stripped))
+            return true; // IPv4-mapped loopback
+        return false;
+    };
+    // IPv6 bracketed form: [::1]:11435
+    const bracketed = bind.match(/^\[([^\]]+)\]:\d+$/);
+    if (bracketed)
+        return hostPart(bracketed[1]);
+    // host:port (IPv4 or hostname) — split on the LAST colon so a bare IPv6
+    // address without brackets (ambiguous, shouldn't occur in practice) isn't
+    // misparsed as host:port.
+    const lastColon = bind.lastIndexOf(':');
+    const host = lastColon === -1 ? bind : bind.slice(0, lastColon);
+    return hostPart(host);
+}
+//# sourceMappingURL=paths.js.map

package/v3/@claude-flow/cli/dist/src/proxy/release.d.ts

@@ -0,0 +1,47 @@
+/**
+ * meta-proxy release resolution + download (ADR-307).
+ *
+ * Two download paths, deliberately not conflated:
+ * - **Production** (`downloadReleaseAsset`): public, signed assets from
+ *   cognitum-one/meta-proxy-dist. Source remains private; normal users need
+ *   neither GitHub authentication nor access to the source repository.
+ * - **Dev-only** (`downloadViaGhCli`): shells out to `gh release download`,
+ *   gated behind `RUFLO_DEV_PROXY_INSTALL=1` so it is never reachable by
+ *   accident, and always logs loudly that it is a developer path.
+ *
+ * @module proxy/release
+ */
+export declare const TARGET_TRIPLES: readonly ["aarch64-apple-darwin", "x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "aarch64-unknown-linux-gnu", "x86_64-pc-windows-msvc"];
+export type TargetTriple = (typeof TARGET_TRIPLES)[number];
+export declare class UnsupportedPlatformError extends Error {
+    constructor(platform: string, arch: string);
+}
+/** Maps the running Node process's platform/arch onto one of meta-proxy's 5 published triples. */
+export declare function detectTargetTriple(platform?: string, arch?: string): TargetTriple;
+export declare function releaseArchiveExtension(triple: TargetTriple): 'zip' | 'tar.gz';
+export declare function releaseAssetFilename(version: string, triple: TargetTriple): string;
+export interface ReleaseAssets {
+    archiveBytes: Buffer;
+    archiveFilename: string;
+    sumsBytes: Buffer;
+    sigBase64: string;
+}
+/**
+ * Dev-only fallback: `gh release download` via SafeExecutor into `destDir`.
+ * Requires the caller's environment to already have `gh` authenticated
+ * against a GitHub account with access to the private meta-proxy repo — this
+ * is NOT something a normal ruflo end user has, which is exactly why this
+ * path is gated and logged, not the default.
+ */
+export declare function downloadViaGhCli(destDir: string, version: string, triple: TargetTriple, log?: (line: string) => void): Promise<ReleaseAssets>;
+/**
+ * Production download path — a Cognitum-owned, auth-mediated release-proxy
+ * endpoint. Not implemented: no such endpoint exists in the confirmed
+ * OpenAPI contract today. Throws a clear, specific error rather than
+ * silently falling back to the dev path, so a real user hitting this isn't
+ * left guessing whether it's their environment or a genuine gap.
+ */
+export declare function downloadReleaseAsset(version: string, triple: TargetTriple, _destDir: string): Promise<ReleaseAssets>;
+/** Entry point install.ts calls — routes to the dev path when explicitly enabled, else fails clearly. */
+export declare function fetchReleaseAssets(version: string, triple: TargetTriple, destDir: string, log?: (line: string) => void): Promise<ReleaseAssets>;
+//# sourceMappingURL=release.d.ts.map

package/v3/@claude-flow/cli/dist/src/proxy/release.js

@@ -0,0 +1,138 @@
+/**
+ * meta-proxy release resolution + download (ADR-307).
+ *
+ * Two download paths, deliberately not conflated:
+ * - **Production** (`downloadReleaseAsset`): public, signed assets from
+ *   cognitum-one/meta-proxy-dist. Source remains private; normal users need
+ *   neither GitHub authentication nor access to the source repository.
+ * - **Dev-only** (`downloadViaGhCli`): shells out to `gh release download`,
+ *   gated behind `RUFLO_DEV_PROXY_INSTALL=1` so it is never reachable by
+ *   accident, and always logs loudly that it is a developer path.
+ *
+ * @module proxy/release
+ */
+export const TARGET_TRIPLES = [
+    'aarch64-apple-darwin',
+    'x86_64-apple-darwin',
+    'x86_64-unknown-linux-gnu',
+    'aarch64-unknown-linux-gnu',
+    'x86_64-pc-windows-msvc',
+];
+export class UnsupportedPlatformError extends Error {
+    constructor(platform, arch) {
+        super(`meta-proxy has no published release for ${platform}/${arch}`);
+        this.name = 'UnsupportedPlatformError';
+    }
+}
+/** Maps the running Node process's platform/arch onto one of meta-proxy's 5 published triples. */
+export function detectTargetTriple(platform = process.platform, arch = process.arch) {
+    if (platform === 'darwin')
+        return arch === 'arm64' ? 'aarch64-apple-darwin' : 'x86_64-apple-darwin';
+    if (platform === 'linux')
+        return arch === 'arm64' ? 'aarch64-unknown-linux-gnu' : 'x86_64-unknown-linux-gnu';
+    if (platform === 'win32') {
+        if (arch !== 'x64')
+            throw new UnsupportedPlatformError(platform, arch);
+        return 'x86_64-pc-windows-msvc';
+    }
+    throw new UnsupportedPlatformError(platform, arch);
+}
+export function releaseArchiveExtension(triple) {
+    return triple.endsWith('windows-msvc') ? 'zip' : 'tar.gz';
+}
+export function releaseAssetFilename(version, triple) {
+    return `meta-proxy-${version}-${triple}.${releaseArchiveExtension(triple)}`;
+}
+const DEV_INSTALL_ENV = 'RUFLO_DEV_PROXY_INSTALL';
+const RELEASE_SOURCE_ENV = 'RUFLO_PROXY_RELEASE_SOURCE';
+const GH_REPO = 'cognitum-one/meta-proxy';
+const PUBLIC_DIST_BASE = 'https://github.com/cognitum-one/meta-proxy-dist/releases/download';
+const MAX_ARCHIVE_BYTES = 32 * 1024 * 1024;
+async function downloadPublicAsset(url, maxBytes) {
+    const response = await fetch(url, { redirect: 'follow', signal: AbortSignal.timeout(120_000) });
+    if (!response.ok)
+        throw new Error(`release download failed: HTTP ${response.status} for ${url}`);
+    const declared = Number(response.headers.get('content-length') ?? 0);
+    if (declared > maxBytes)
+        throw new Error(`release asset exceeds ${maxBytes} byte limit`);
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (bytes.length > maxBytes)
+        throw new Error(`release asset exceeds ${maxBytes} byte limit`);
+    return bytes;
+}
+async function ghExecutor() {
+    // Dynamic import, not a static one: @claude-flow/security is only an
+    // optionalDependency of this package (see auth/security-bridge.ts for the
+    // same reasoning) — a static top-level import would crash module load for
+    // any consumer that doesn't have it installed, even ones that never touch
+    // this dev-only download path.
+    const { SafeExecutor } = await import('@claude-flow/security');
+    return new SafeExecutor({ allowedCommands: ['gh'], timeout: 120_000 });
+}
+/**
+ * Dev-only fallback: `gh release download` via SafeExecutor into `destDir`.
+ * Requires the caller's environment to already have `gh` authenticated
+ * against a GitHub account with access to the private meta-proxy repo — this
+ * is NOT something a normal ruflo end user has, which is exactly why this
+ * path is gated and logged, not the default.
+ */
+export async function downloadViaGhCli(destDir, version, triple, log = () => { }) {
+    const archiveFilename = releaseAssetFilename(version, triple);
+    log(`[dev-only] Downloading meta-proxy ${version} (${triple}) via \`gh release download\` — ` +
+        'this path is NOT how production installs work; it exists for local development only ' +
+        `(gated behind ${DEV_INSTALL_ENV}=1).`);
+    const exec = await ghExecutor();
+    const result = await exec.execute('gh', [
+        'release',
+        'download',
+        `v${version}`,
+        '--repo',
+        GH_REPO,
+        '--dir',
+        destDir,
+        '--pattern',
+        archiveFilename,
+        '--pattern',
+        'SHA256SUMS',
+        '--pattern',
+        'SHA256SUMS.sig',
+        '--clobber',
+    ]);
+    if (result.exitCode !== 0) {
+        throw new Error(`gh release download failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`);
+    }
+    const { readFile } = await import('node:fs/promises');
+    const { join } = await import('node:path');
+    const [archiveBytes, sumsBytes, sigRaw] = await Promise.all([
+        readFile(join(destDir, archiveFilename)),
+        readFile(join(destDir, 'SHA256SUMS')),
+        readFile(join(destDir, 'SHA256SUMS.sig'), 'utf-8'),
+    ]);
+    return { archiveBytes, archiveFilename, sumsBytes, sigBase64: sigRaw.trim() };
+}
+/**
+ * Production download path — a Cognitum-owned, auth-mediated release-proxy
+ * endpoint. Not implemented: no such endpoint exists in the confirmed
+ * OpenAPI contract today. Throws a clear, specific error rather than
+ * silently falling back to the dev path, so a real user hitting this isn't
+ * left guessing whether it's their environment or a genuine gap.
+ */
+export async function downloadReleaseAsset(version, triple, _destDir) {
+    const archiveFilename = releaseAssetFilename(version, triple);
+    const base = (process.env[RELEASE_SOURCE_ENV] || PUBLIC_DIST_BASE).replace(/\/$/, '');
+    const release = `${base}/v${encodeURIComponent(version)}`;
+    const [archiveBytes, sumsBytes, sigBytes] = await Promise.all([
+        downloadPublicAsset(`${release}/${archiveFilename}`, MAX_ARCHIVE_BYTES),
+        downloadPublicAsset(`${release}/SHA256SUMS`, 128 * 1024),
+        downloadPublicAsset(`${release}/SHA256SUMS.sig`, 16 * 1024),
+    ]);
+    return { archiveBytes, archiveFilename, sumsBytes, sigBase64: sigBytes.toString('utf8').trim() };
+}
+/** Entry point install.ts calls — routes to the dev path when explicitly enabled, else fails clearly. */
+export async function fetchReleaseAssets(version, triple, destDir, log) {
+    if (process.env[DEV_INSTALL_ENV] === '1') {
+        return downloadViaGhCli(destDir, version, triple, log);
+    }
+    return downloadReleaseAsset(version, triple, destDir);
+}
+//# sourceMappingURL=release.js.map

package/v3/@claude-flow/cli/dist/src/proxy/token-bridge.d.ts

@@ -0,0 +1,5 @@
+/** ADR-318 access-token-only bridge from ruflo auth to meta-proxy. */
+export declare function removeInjectedToken(): void;
+export declare function refreshInjectedToken(): Promise<boolean>;
+export declare function startTokenRefreshPump(): Promise<() => void>;
+//# sourceMappingURL=token-bridge.d.ts.map

package/v3/@claude-flow/cli/dist/src/proxy/token-bridge.js

@@ -0,0 +1,61 @@
+/** ADR-318 access-token-only bridge from ruflo auth to meta-proxy. */
+import * as fs from 'node:fs';
+import { dirname } from 'node:path';
+import { getValidAccessToken } from '../auth/client.js';
+import { getProfile, listProfiles } from '../auth/state.js';
+import { proxyConfigPath, proxyInjectedTokenPath } from './paths.js';
+const REFRESH_POLL_MS = 30_000;
+function configureInjectedTokenPath() {
+    const target = proxyConfigPath();
+    fs.mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
+    const raw = fs.existsSync(target) ? fs.readFileSync(target, 'utf8') : '';
+    const line = `ruflo_injected_token_path = ${JSON.stringify(proxyInjectedTokenPath())}`;
+    const pattern = /^ruflo_injected_token_path\s*=.*$/m;
+    const next = pattern.test(raw) ? raw.replace(pattern, line) : `${raw}${raw && !raw.endsWith('\n') ? '\n' : ''}${line}\n`;
+    const tmp = `${target}.tmp-${process.pid}`;
+    fs.writeFileSync(tmp, next, { encoding: 'utf8', mode: 0o600 });
+    fs.renameSync(tmp, target);
+}
+export function removeInjectedToken() {
+    try {
+        fs.unlinkSync(proxyInjectedTokenPath());
+    }
+    catch { /* absent */ }
+}
+export async function refreshInjectedToken() {
+    const { defaultProfile } = listProfiles();
+    const profile = getProfile(defaultProfile);
+    if (!profile) {
+        removeInjectedToken();
+        return false;
+    }
+    try {
+        const accessToken = await getValidAccessToken(defaultProfile);
+        const current = getProfile(defaultProfile);
+        if (!current)
+            return false;
+        const body = JSON.stringify({ schemaVersion: 1, accessToken, expiresAt: current.accessTokenExpiresAt });
+        configureInjectedTokenPath();
+        const target = proxyInjectedTokenPath();
+        const tmp = `${target}.tmp-${process.pid}`;
+        fs.writeFileSync(tmp, body, { encoding: 'utf8', mode: 0o600 });
+        fs.chmodSync(tmp, 0o600);
+        fs.renameSync(tmp, target);
+        return true;
+    }
+    catch {
+        removeInjectedToken();
+        return false;
+    }
+}
+export async function startTokenRefreshPump() {
+    await refreshInjectedToken();
+    const timer = setInterval(() => void refreshInjectedToken(), REFRESH_POLL_MS);
+    const stop = () => {
+        clearInterval(timer);
+        removeInjectedToken();
+    };
+    process.once('exit', removeInjectedToken);
+    return stop;
+}
+//# sourceMappingURL=token-bridge.js.map

package/v3/@claude-flow/cli/dist/src/proxy/verify.d.ts

@@ -0,0 +1,44 @@
+/**
+ * meta-proxy release verification (ADR-307) — mirrors src/init/helper-signing.ts's
+ * raw-EdDSA `crypto.verify(null, ...)` pattern almost exactly, and matches the
+ * exact scheme confirmed live 2026-07-16 against a real v0.1.0 release: ONE
+ * combined `SHA256SUMS.sig` (raw Ed25519 over the `SHA256SUMS` file's bytes,
+ * base64-encoded — not a per-binary signature), then a per-asset SHA-256
+ * check against the matching `SHA256SUMS` line. Refuse-all-or-nothing on any
+ * mismatch, same discipline as `writeCriticalHelpers()`.
+ *
+ * @module proxy/verify
+ */
+/**
+ * meta-proxy's committed release-signing public key (SPKI PEM), confirmed
+ * live 2026-07-16 by verifying a real `SHA256SUMS.sig` from the v0.1.0
+ * release against it (crypto.verify -> true).
+ */
+export declare const PROXY_RELEASE_PUBKEY_PEM = "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAjhLDomjIGdcltYC7j+aiESQFD4LWoHaULietG1PuDjw=\n-----END PUBLIC KEY-----";
+export declare class ReleaseVerificationError extends Error {
+    constructor(message: string);
+}
+/** Raw EdDSA verify of `SHA256SUMS.sig` (base64) over `SHA256SUMS`'s exact bytes. */
+export declare function verifySha256SumsSignature(sumsBytes: Buffer, sigBase64: string, pubkeyPem?: string): boolean;
+export type ParsedChecksums = Record<string, string>;
+/** Parses `<sha256>  <filename>` lines (sha256sum's own output format). */
+export declare function parseSha256Sums(sumsText: string): ParsedChecksums;
+export declare function sha256Hex(bytes: Buffer): string;
+export interface VerifyReleaseInput {
+    sumsBytes: Buffer;
+    sigBase64: string;
+    assetBytes: Buffer;
+    assetFilename: string;
+    pubkeyPem?: string;
+}
+export interface VerifyReleaseResult {
+    sha256: string;
+}
+/**
+ * Full verification: signature over SHA256SUMS, then the asset's own hash
+ * against the matching line. Throws `ReleaseVerificationError` on ANY
+ * failure — there is no partial-trust outcome, matching ADR-307's "refuses
+ * on any mismatch" requirement.
+ */
+export declare function verifyRelease(input: VerifyReleaseInput): VerifyReleaseResult;
+//# sourceMappingURL=verify.d.ts.map

package/v3/@claude-flow/cli/dist/src/proxy/verify.js

@@ -0,0 +1,68 @@
+/**
+ * meta-proxy release verification (ADR-307) — mirrors src/init/helper-signing.ts's
+ * raw-EdDSA `crypto.verify(null, ...)` pattern almost exactly, and matches the
+ * exact scheme confirmed live 2026-07-16 against a real v0.1.0 release: ONE
+ * combined `SHA256SUMS.sig` (raw Ed25519 over the `SHA256SUMS` file's bytes,
+ * base64-encoded — not a per-binary signature), then a per-asset SHA-256
+ * check against the matching `SHA256SUMS` line. Refuse-all-or-nothing on any
+ * mismatch, same discipline as `writeCriticalHelpers()`.
+ *
+ * @module proxy/verify
+ */
+import { createHash, createPublicKey, verify as cryptoVerify } from 'node:crypto';
+/**
+ * meta-proxy's committed release-signing public key (SPKI PEM), confirmed
+ * live 2026-07-16 by verifying a real `SHA256SUMS.sig` from the v0.1.0
+ * release against it (crypto.verify -> true).
+ */
+export const PROXY_RELEASE_PUBKEY_PEM = `-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEAjhLDomjIGdcltYC7j+aiESQFD4LWoHaULietG1PuDjw=
+-----END PUBLIC KEY-----`;
+export class ReleaseVerificationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ReleaseVerificationError';
+    }
+}
+/** Raw EdDSA verify of `SHA256SUMS.sig` (base64) over `SHA256SUMS`'s exact bytes. */
+export function verifySha256SumsSignature(sumsBytes, sigBase64, pubkeyPem = PROXY_RELEASE_PUBKEY_PEM) {
+    const pubkey = createPublicKey(pubkeyPem);
+    const sig = Buffer.from(sigBase64.trim(), 'base64');
+    return cryptoVerify(null, sumsBytes, pubkey, sig);
+}
+/** Parses `<sha256>  <filename>` lines (sha256sum's own output format). */
+export function parseSha256Sums(sumsText) {
+    const result = {};
+    for (const line of sumsText.split(/\r?\n/)) {
+        const match = line.match(/^([0-9a-f]{64})\s+(.+)$/i);
+        if (!match)
+            continue;
+        result[match[2]] = match[1].toLowerCase();
+    }
+    return result;
+}
+export function sha256Hex(bytes) {
+    return createHash('sha256').update(bytes).digest('hex');
+}
+/**
+ * Full verification: signature over SHA256SUMS, then the asset's own hash
+ * against the matching line. Throws `ReleaseVerificationError` on ANY
+ * failure — there is no partial-trust outcome, matching ADR-307's "refuses
+ * on any mismatch" requirement.
+ */
+export function verifyRelease(input) {
+    if (!verifySha256SumsSignature(input.sumsBytes, input.sigBase64, input.pubkeyPem)) {
+        throw new ReleaseVerificationError('SHA256SUMS.sig failed Ed25519 verification — refusing to install');
+    }
+    const sums = parseSha256Sums(input.sumsBytes.toString('utf-8'));
+    const expected = sums[input.assetFilename];
+    if (!expected) {
+        throw new ReleaseVerificationError(`SHA256SUMS has no entry for ${input.assetFilename}`);
+    }
+    const actual = sha256Hex(input.assetBytes);
+    if (actual !== expected) {
+        throw new ReleaseVerificationError(`sha256 mismatch for ${input.assetFilename}: expected ${expected.slice(0, 12)}…, got ${actual.slice(0, 12)}…`);
+    }
+    return { sha256: actual };
+}
+//# sourceMappingURL=verify.js.map

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.32.2",
+  "version": "3.32.8",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",
@@ -111,8 +111,8 @@
     "yaml": "^2.8.0"
   },
   "optionalDependencies": {
-    "@claude-flow/memory": "^3.0.0-alpha.21",
-    "@claude-flow/security": "^3.0.0-alpha.10",
+    "@claude-flow/memory": "^3.0.0-alpha.21",
+    "@claude-flow/security": "^3.0.0-alpha.12",
     "agentdb": "^3.0.0-alpha.17",
     "agentic-flow": "^3.0.0-alpha.1",
     "ruvector": "^0.2.27"

package/.claude/.proven-config-version

@@ -1 +0,0 @@
-sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319

package/.claude/proven-config.json

@@ -1,42 +0,0 @@
-{
-  "adoptedAt": 1784256882562,
-  "championId": "sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319",
-  "manifest": {
-    "schema": "ruflo.proven-config/v1",
-    "policy": {
-      "ref": "sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319",
-      "value": {
-        "alpha": 0.3,
-        "subjectWeight": 1,
-        "mmrLambda": 0.5,
-        "bodyWeight": 1.5,
-        "typePenaltyFactor": 0.5
-      }
-    },
-    "layer": "framework/node-cli",
-    "compatibility": {
-      "ruflo": ">=3.24.0"
-    },
-    "benchmark": {
-      "corpus": "ADR-081-labelled-v1",
-      "corpusHash": "sha256:2f700b5c363e20a3bd88ce2bc9b87bbbbaa61732c6177894c6ec37890f888982"
-    },
-    "receipt": {
-      "heldOutDelta": 0.07381404928570845,
-      "redblue": "PASS",
-      "drift": 0,
-      "canary": {
-        "rollbackRate": 0,
-        "latencyP95": 244.612458000076,
-        "costPerTask": 0
-      },
-      "receiptCoverage": 1
-    },
-    "platform": [
-      "linux",
-      "macOS",
-      "windows"
-    ]
-  },
-  "previous": ""
-}