claude-flow 3.61.1 → 3.63.0

package/v3/@claude-flow/cli/dist/src/services/managed-run-collector.js

@@ -0,0 +1,181 @@
+/** One explicit, bounded event collector per managed session. No background traffic. */
+import { isDeepStrictEqual } from 'node:util';
+import { eventPage, ManagedProgress } from './managed-workflows.js';
+export const COLLECTOR_LIMITS = { sessions: 6, events: 10_000, bytes: 16_000_000, shownThreads: 60, staleMs: 300_000 };
+const idOf = (v) => typeof v === 'string' && /^[A-Za-z0-9_-]{1,128}$/.test(v) ? v : undefined;
+const record = (v) => v && typeof v === 'object' && !Array.isArray(v) ? v : undefined;
+const clone = (v) => JSON.parse(JSON.stringify(v));
+const cents = (v) => {
+    const r = record(v);
+    return r && (r.currency === undefined || r.currency === 'USD') && typeof r.amount === 'string' && /^(?:0|[1-9][0-9]{0,8})$/.test(r.amount) ? Number(r.amount) : null;
+};
+const phaseName = (v, fallback) => {
+    if (typeof v !== 'string')
+        return fallback;
+    if (/sk-|ghp_|github_pat_|hf_|npm_|xox|AKIA|AIza|Bearer|PRIVATE KEY|password|secret|credential|[A-Za-z0-9_=-]{24,}|token["']?\s*[:=]/i.test(v))
+        return '[redacted phase]';
+    return v.replace(/[\u0000-\u001f\u007f-\u009f\u200b-\u200f\u202a-\u202e\u2060-\u206f]/g, '').slice(0, 80) || fallback;
+};
+/** This cache is an observation aid. Cached facts never authorize an action. */
+export class ManagedRunCollector {
+    states = new Map();
+    now;
+    ttlMs;
+    constructor(options = {}) {
+        this.now = options.now ?? Date.now;
+        this.ttlMs = options.ttlMs ?? 1000;
+        if (!Number.isFinite(this.ttlMs) || this.ttlMs < 0 || this.ttlMs > 60_000)
+            throw new Error('Invalid collector TTL');
+    }
+    /** Singleflight includes event and session reads; a failed refresh is never cached as success. */
+    refresh(sessionId, transport) {
+        if (!idOf(sessionId))
+            return Promise.reject(new Error('Invalid managed session ID'));
+        let state = this.states.get(sessionId);
+        if (!state) {
+            if (this.states.size >= COLLECTOR_LIMITS.sessions) {
+                const oldest = [...this.states.entries()].filter(([, s]) => !s.flight && (this.now() - s.lastUsed >= COLLECTOR_LIMITS.staleMs || ['idle', 'terminated', 'error'].includes(s.result?.snapshot.status ?? 'unknown'))).sort((a, b) => a[1].lastUsed - b[1].lastUsed)[0];
+                if (!oldest)
+                    return Promise.reject(new Error('Managed collector session limit reached'));
+                this.states.delete(oldest[0]);
+            }
+            state = { events: new Map(), bytes: 0, progress: new ManagedProgress(), threads: new Map(), phases: new Map(), blocked: new Set(), session: {}, lastRead: -Infinity, lastUsed: this.now() };
+            this.states.set(sessionId, state);
+        }
+        state.lastUsed = this.now();
+        if (state.flight)
+            return state.flight.then(clone);
+        if (state.result && this.now() - state.lastRead < this.ttlMs)
+            return Promise.resolve(clone(state.result));
+        const s = state;
+        // Start transport in a microtask so reentrant callers also see the flight.
+        s.flight = Promise.resolve().then(async () => {
+            const [events, session] = await Promise.all([transport.readEvents(s.progress.watermark()), transport.readSession()]);
+            if (!record(session))
+                throw new Error('Invalid managed session response');
+            const validated = eventPage({ data: events }).data;
+            const additions = [];
+            let bytes = s.bytes, total = s.events.size;
+            const batch = new Map();
+            for (const input of validated) {
+                const e = clone(input), previous = batch.get(e.id) ?? s.events.get(e.id);
+                if (previous?.processed_at && !isDeepStrictEqual(previous, e))
+                    throw new Error('Conflicting managed event replay');
+                if (previous && isDeepStrictEqual(previous, e))
+                    continue;
+                bytes += Buffer.byteLength(JSON.stringify(e)) - (previous ? Buffer.byteLength(JSON.stringify(previous)) : 0);
+                if (!previous)
+                    total++;
+                if (total > COLLECTOR_LIMITS.events || bytes > COLLECTOR_LIMITS.bytes)
+                    throw new Error('Managed collector event limit exceeded');
+                batch.set(e.id, e);
+            }
+            for (const e of batch.values())
+                additions.push(e);
+            s.progress.accept(additions);
+            s.bytes = bytes;
+            for (const e of additions) {
+                s.events.set(e.id, e);
+                if (e.processed_at)
+                    this.observe(s, e);
+            }
+            s.session = clone(session);
+            s.lastRead = this.now();
+            const p = s.progress.snapshot();
+            const threadCounts = { running: 0, ended: 0, failed: 0, idle: 0 };
+            for (const t of s.threads.values()) {
+                if (t.status === 'running')
+                    threadCounts.running++;
+                else if (t.status === 'failed')
+                    threadCounts.failed++;
+                else if (t.status === 'ended' || t.status === 'terminated')
+                    threadCounts.ended++;
+                else
+                    threadCounts.idle++;
+            }
+            const snapshot = {
+                sessionId, status: ['idle', 'running', 'rescheduling', 'terminated', 'error'].includes(session.status ?? '') ? session.status : p.status,
+                stopReason: p.stopReason === null || ['end_turn', 'budget_reached', 'requires_action'].includes(p.stopReason) ? p.stopReason : 'unknown', budgetCents: cents(session.budget?.max_list_cost), listCostCents: cents(session.usage?.list_cost) ?? cents(p.listCost),
+                providerFinished: p.finished && session.status !== 'running' && session.status !== 'rescheduling' && session.status !== 'terminated',
+                workersInspected: false, acceptancePassed: false, verification: 'unverified',
+                runs: p.workflowRuns.map(r => ({ ...r, phases: [...(s.phases.get(r.id)?.values() ?? [])] })),
+                threads: [...s.threads.values()].slice(0, COLLECTOR_LIMITS.shownThreads), threadOffset: 0, threadCount: s.threads.size, threadCounts,
+                blockedEventIds: [...s.blocked], observedFailures: Math.max(p.observedFailures, threadCounts.failed), updatedMs: s.lastRead,
+            };
+            s.result = { events: [...s.events.values()], snapshot };
+            return s.result;
+        }).finally(() => { s.flight = undefined; });
+        return s.flight.then(clone);
+    }
+    /** Pure observation, suitable for disk snapshot publication. Never invokes a transport. */
+    snapshots() { return [...this.states.values()].flatMap(s => s.result ? [clone(s.result.snapshot)] : []); }
+    /** A local worker page only. Aggregate counts and observation timestamp do not change. */
+    page(sessionId, threadOffset = 0) {
+        if (!Number.isSafeInteger(threadOffset) || threadOffset < 0 || threadOffset >= COLLECTOR_LIMITS.events)
+            throw new Error('Invalid managed thread offset');
+        const state = this.states.get(sessionId);
+        if (!state?.result)
+            return undefined;
+        return { ...clone(state.result.snapshot), threadOffset, threads: clone([...state.threads.values()].slice(threadOffset, threadOffset + COLLECTOR_LIMITS.shownThreads)) };
+    }
+    /** A collector doing work cannot be forgotten midflight. No remote work is interrupted. */
+    forget(sessionId) {
+        const s = this.states.get(sessionId);
+        return s?.flight ? false : this.states.delete(sessionId);
+    }
+    observe(s, e) {
+        const runId = idOf(e.workflow_run_id);
+        if (runId && e.type === 'workflow_run.created' && Array.isArray(e.phases)) {
+            const phases = new Map();
+            for (const value of e.phases.slice(0, 100)) {
+                const phase = record(value), id = idOf(phase?.id);
+                if (id)
+                    phases.set(id, { id, name: phaseName(phase?.name, id), status: 'queued' });
+            }
+            s.phases.set(runId, phases);
+        }
+        if (runId && (e.type === 'workflow_run.phase_started' || e.type === 'workflow_run.phase_ended')) {
+            const id = idOf(e.workflow_run_phase_id);
+            if (id) {
+                const phases = s.phases.get(runId) ?? new Map();
+                if (phases.size < 100 || phases.has(id))
+                    phases.set(id, { id, name: phases.get(id)?.name ?? id, status: e.type.endsWith('started') ? 'running' : 'ended' });
+                s.phases.set(runId, phases);
+            }
+        }
+        const threadId = idOf(e.session_thread_id);
+        if (threadId && e.type.startsWith('session.thread_')) {
+            const t = s.threads.get(threadId) ?? { id: threadId, runId: runId ?? null, status: 'idle' };
+            if (runId)
+                t.runId = runId;
+            const phaseId = idOf(e.workflow_run_phase_id);
+            if (phaseId)
+                t.phaseId = phaseId;
+            if (e.type === 'session.thread_status_running')
+                t.status = 'running';
+            else if (e.type === 'session.thread_status_idle')
+                t.status = 'idle';
+            else if (e.type === 'session.thread_status_terminated')
+                t.status = e.error || t.status === 'failed' ? 'failed' : 'ended';
+            s.threads.set(threadId, t);
+        }
+        if (threadId && e.type === 'session.error') {
+            const t = s.threads.get(threadId) ?? { id: threadId, runId: runId ?? null, status: 'failed' };
+            t.status = 'failed';
+            s.threads.set(threadId, t);
+        }
+        const permission = typeof e.evaluated_permission === 'string' ? e.evaluated_permission : record(e.evaluated_permission)?.type;
+        if (permission === 'ask' || e.type === 'agent.custom_tool_use')
+            s.blocked.add(e.id);
+        const answered = idOf(e.tool_use_id) ?? idOf(e.custom_tool_use_id);
+        if (answered && ['user.tool_confirmation', 'user.custom_tool_result', 'user.tool_result'].includes(e.type))
+            s.blocked.delete(answered);
+        const stop = record(e.stop_reason);
+        if (stop?.type === 'requires_action' && Array.isArray(stop.event_ids))
+            for (const id of stop.event_ids)
+                if (idOf(id))
+                    s.blocked.add(id);
+    }
+}
+export const sharedManagedCollector = new ManagedRunCollector();
+//# sourceMappingURL=managed-run-collector.js.map

package/v3/@claude-flow/cli/dist/src/services/managed-run-store.d.ts

@@ -0,0 +1,52 @@
+import type { ManagedRunSnapshot } from './managed-run-collector.js';
+/** Other processes fail rather than poll twice. Never automatically steal a lease. */
+export declare function collectWithLease<T>(root: string, sessionId: string, action: () => Promise<T>, scope?: string): Promise<T>;
+export declare function publishManagedSnapshot(root: string, snapshot: ManagedRunSnapshot): void;
+export type ControlAction = 'inspect' | 'interrupt' | 'terminate';
+/** Host settings are read again immediately before side effects, never from console facts. */
+export declare function executeManagedControl(input: Record<string, unknown>, deps: {
+    policy: () => {
+        enabled: boolean;
+        sessions: string[];
+    };
+    read: (sessionId: string) => Promise<{
+        status?: string;
+    }>;
+    inspect: (sessionId: string, offset: number) => Promise<unknown>;
+    interrupt: (sessionId: string) => Promise<unknown>;
+    terminate: (sessionId: string) => Promise<unknown>;
+}): Promise<{
+    success: boolean;
+    currentStatus: string | undefined;
+    snapshot: unknown;
+    cancellationConfirmed?: undefined;
+    interruptRequested?: undefined;
+    result?: undefined;
+} | {
+    success: boolean;
+    currentStatus: string;
+    cancellationConfirmed: boolean;
+    snapshot?: undefined;
+    interruptRequested?: undefined;
+    result?: undefined;
+} | {
+    success: boolean;
+    currentStatus: string | undefined;
+    interruptRequested: boolean;
+    cancellationConfirmed: boolean;
+    result: unknown;
+    snapshot?: undefined;
+} | {
+    success: boolean;
+    currentStatus: string | undefined;
+    cancellationConfirmed: boolean;
+    result: unknown;
+    snapshot?: undefined;
+    interruptRequested?: undefined;
+}>;
+/** Successful provider deletion is a session fact, never an acceptance verdict. */
+export declare function publishManagedTermination(root: string, sessionId: string, collector: {
+    page: (id: string) => ManagedRunSnapshot | undefined;
+    forget: (id: string) => boolean;
+}): void;
+//# sourceMappingURL=managed-run-store.d.ts.map

package/v3/@claude-flow/cli/dist/src/services/managed-run-store.js

@@ -0,0 +1,119 @@
+/** Bounded console projections and a fail-closed cross-process collector lease. */
+import { closeSync, constants, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { randomUUID } from 'node:crypto';
+const flights = new Map();
+function folder(root) {
+    let p = resolve(root);
+    if (!lstatSync(p).isDirectory())
+        throw new Error('Invalid managed project root');
+    for (const name of ['.claude-flow', 'managed-workflows']) {
+        p = join(p, name);
+        if (!existsSync(p))
+            mkdirSync(p, { mode: 0o700 });
+        if (!lstatSync(p).isDirectory() || lstatSync(p).isSymbolicLink())
+            throw new Error('Managed snapshot directory must be regular');
+    }
+    return p;
+}
+/** Other processes fail rather than poll twice. Never automatically steal a lease. */
+export function collectWithLease(root, sessionId, action, scope = '') {
+    if (!/^sesn_[A-Za-z0-9]+$/.test(sessionId))
+        return Promise.reject(new Error('Invalid managed session ID'));
+    const path = join(folder(root), `${sessionId}.collector.lock`);
+    const pending = flights.get(path);
+    if (pending)
+        return pending.scope === scope ? pending.promise.then(v => structuredClone(v)) : Promise.reject(new Error('Managed collector belongs to another credential scope'));
+    let fd;
+    try {
+        fd = openSync(path, 'wx', 0o600);
+    }
+    catch {
+        return Promise.reject(new Error('Managed collector is leased by another process; inspect before recovering a stale lease'));
+    }
+    const flight = Promise.resolve().then(action).finally(() => { closeSync(fd); unlinkSync(path); flights.delete(path); });
+    flights.set(path, { scope, promise: flight });
+    return flight.then(v => structuredClone(v));
+}
+/** Read only the fixed, capped projection. It has no authorization role. */
+function previous(path) {
+    if (!existsSync(path))
+        return [];
+    if (!lstatSync(path).isFile() || lstatSync(path).isSymbolicLink())
+        throw new Error('Invalid managed snapshot file');
+    const fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    try {
+        const buffer = Buffer.alloc(128_001);
+        const count = readSync(fd, buffer, 0, buffer.length, 0);
+        if (count > 128_000)
+            throw new Error('Managed snapshot exceeds limit');
+        const value = JSON.parse(buffer.subarray(0, count).toString('utf8'));
+        if (value.version !== 1 || !Array.isArray(value.sessions) || value.sessions.length > 6)
+            throw new Error('Invalid managed snapshot');
+        return value.sessions;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export function publishManagedSnapshot(root, snapshot) {
+    const dir = folder(root), lockPath = join(dir, 'snapshot.lock');
+    const fd = openSync(lockPath, 'wx', 0o600), temp = join(dir, `${randomUUID()}.tmp`);
+    try {
+        const path = join(dir, 'snapshot.json');
+        const old = previous(path);
+        const sessions = [snapshot, ...old.filter(s => s.sessionId !== snapshot.sessionId)].slice(0, 6);
+        if (JSON.stringify(sessions) === JSON.stringify(old))
+            return;
+        const text = JSON.stringify({ version: 1, updatedMs: Date.now(), sessions });
+        if (Buffer.byteLength(text) > 128_000)
+            throw new Error('Managed snapshot exceeds limit');
+        const out = openSync(temp, 'wx', 0o600);
+        try {
+            writeFileSync(out, text);
+            fsyncSync(out);
+        }
+        finally {
+            closeSync(out);
+        }
+        renameSync(temp, path);
+    }
+    finally {
+        if (existsSync(temp))
+            unlinkSync(temp);
+        closeSync(fd);
+        unlinkSync(lockPath);
+    }
+}
+/** Host settings are read again immediately before side effects, never from console facts. */
+export async function executeManagedControl(input, deps) {
+    const sessionId = input.sessionId, action = input.action;
+    if (Object.keys(input).some(k => !['sessionId', 'action', 'threadOffset'].includes(k)) || typeof sessionId !== 'string' || !/^sesn_[A-Za-z0-9]+$/.test(sessionId) || !['inspect', 'interrupt', 'terminate'].includes(String(action)))
+        throw new Error('Invalid managed control request');
+    const offset = input.threadOffset ?? 0;
+    if (!Number.isSafeInteger(offset) || offset < 0 || offset >= 10_000 || (action !== 'inspect' && input.threadOffset !== undefined))
+        throw new Error('Invalid managed worker page');
+    const allowed = () => { const p = deps.policy(); return p.enabled && p.sessions.includes(sessionId); };
+    if (!allowed())
+        throw new Error('Host managed control policy denies this session');
+    const current = await deps.read(sessionId);
+    if (!current || !['idle', 'running', 'rescheduling', 'terminated'].includes(current.status ?? ''))
+        throw new Error('Unknown provider session state');
+    if (!allowed())
+        throw new Error('Host managed control policy changed before dispatch');
+    if (action === 'inspect')
+        return { success: true, currentStatus: current.status, snapshot: await deps.inspect(sessionId, offset) };
+    if (current.status === 'terminated')
+        return { success: true, currentStatus: 'terminated', cancellationConfirmed: true };
+    if (action === 'interrupt')
+        return { success: true, currentStatus: current.status, interruptRequested: true, cancellationConfirmed: false, result: await deps.interrupt(sessionId) };
+    return { success: true, currentStatus: current.status, cancellationConfirmed: true, result: await deps.terminate(sessionId) };
+}
+/** Successful provider deletion is a session fact, never an acceptance verdict. */
+export function publishManagedTermination(root, sessionId, collector) {
+    const snapshot = collector.page(sessionId);
+    if (snapshot)
+        publishManagedSnapshot(root, { ...snapshot, status: 'terminated', providerFinished: false, updatedMs: Date.now() });
+    collector.forget(sessionId);
+}
+//# sourceMappingURL=managed-run-store.js.map

package/v3/@claude-flow/cli/dist/src/services/managed-workflows.d.ts

@@ -0,0 +1,101 @@
+/** Provider event semantics for ADR-115 / dynamic workflows. No model calls. */
+export interface ManagedEvent {
+    id: string;
+    type: string;
+    processed_at?: string | null;
+    content?: Array<{
+        type: string;
+        text?: string;
+    }>;
+    name?: string;
+    input?: unknown;
+    stop_reason?: {
+        type: string;
+    };
+    workflow_run_id?: string | null;
+    session_thread_id?: string;
+    result?: {
+        type: string;
+    } | string;
+    [key: string]: unknown;
+}
+export interface EventPage {
+    data: ManagedEvent[];
+    next_page?: string | null;
+}
+/** Validate untrusted pages before deriving lifecycle claims. */
+export declare function eventPage(value: unknown): EventPage;
+/** Reads complete history, bounded and deduplicated. Cursor is opaque, never a URL. */
+export declare function readManagedEvents(read: (query: string) => Promise<unknown>, since?: string): Promise<ManagedEvent[]>;
+/** Incremental reducer. Provider completion is always unverified. */
+export declare class ManagedProgress {
+    private seen;
+    private text;
+    private tools;
+    private runs;
+    private failures;
+    private status;
+    private stopReason;
+    private cost;
+    private since;
+    private bytes;
+    private finished;
+    private interrupted;
+    accept(events: ManagedEvent[]): void;
+    watermark(): string | undefined;
+    snapshot(): {
+        assistantText: string;
+        toolUses: {
+            name: string;
+            input: unknown;
+        }[];
+        status: string;
+        stopReason: string | null;
+        eventCount: number;
+        workflowRuns: {
+            id: string;
+            status: string;
+            result?: string;
+        }[];
+        openRuns: number;
+        finished: boolean;
+        interrupted: boolean;
+        blocked: boolean;
+        observedFailures: number;
+        listCost: unknown;
+        verification: "unverified";
+        needsThreadInspection: boolean;
+    };
+}
+/** Build only the supported configuration; do not pass arbitrary multiagent JSON. */
+export declare function dynamicConfig(input: Record<string, unknown>): {
+    enabled: boolean;
+    budget: {
+        type: string;
+        max_list_cost: {
+            amount: string;
+            currency: string;
+        };
+    } | undefined;
+    multiagent: {
+        type: string;
+        subagents: {
+            type: string;
+        };
+        workflows: {
+            inline_agents?: {
+                type: string;
+            } | undefined;
+            predefined_agents?: any[] | undefined;
+            type: string;
+        };
+    } | undefined;
+    networking: {
+        type: string;
+        allowed_hosts: any[];
+    } | {
+        type: {};
+        allowed_hosts?: undefined;
+    };
+};
+//# sourceMappingURL=managed-workflows.d.ts.map

package/v3/@claude-flow/cli/dist/src/services/managed-workflows.js

@@ -0,0 +1,183 @@
+/** Validate untrusted pages before deriving lifecycle claims. */
+export function eventPage(value) {
+    if (!value || typeof value !== 'object')
+        throw new Error('Invalid Managed Agents event page');
+    const page = value;
+    if (!Array.isArray(page.data) || page.data.some(e => !e || typeof e.id !== 'string' || !e.id || typeof e.type !== 'string')) {
+        throw new Error('Invalid Managed Agents events');
+    }
+    for (const e of page.data) {
+        if (e.processed_at != null && (typeof e.processed_at !== 'string' || !Number.isFinite(Date.parse(e.processed_at))))
+            throw new Error('Invalid event timestamp');
+        if (e.type === 'agent.message' && e.content !== undefined && (!Array.isArray(e.content) || e.content.some(b => !b || typeof b.type !== 'string' || (b.text !== undefined && typeof b.text !== 'string'))))
+            throw new Error('Invalid event content');
+        if (e.stop_reason != null && typeof e.stop_reason.type !== 'string')
+            throw new Error('Invalid event stop reason');
+        if (e.type === 'workflow_run.status_ended' && (!e.result || typeof e.result !== 'object' || typeof e.result.type !== 'string'))
+            throw new Error('Invalid workflow result');
+        if (e.type.startsWith('workflow_run.') && e.type !== 'workflow_run.error' && (typeof e.workflow_run_id !== 'string' || !e.workflow_run_id))
+            throw new Error('Invalid workflow ID');
+        if (e.workflow_run_id != null && typeof e.workflow_run_id !== 'string')
+            throw new Error('Invalid workflow ID');
+    }
+    if (page.next_page != null && (typeof page.next_page !== 'string' || !page.next_page || page.next_page.length > 4096)) {
+        throw new Error('Invalid Managed Agents cursor');
+    }
+    return page;
+}
+/** Reads complete history, bounded and deduplicated. Cursor is opaque, never a URL. */
+export async function readManagedEvents(read, since) {
+    const events = new Map();
+    const cursors = new Set();
+    let bytes = 0;
+    let cursor;
+    for (let count = 0; count < 100; count++) {
+        const query = new URLSearchParams({ order: 'asc', limit: '100' });
+        if (cursor)
+            query.set('page', cursor);
+        if (since)
+            query.set('created_at[gte]', since);
+        const page = eventPage(await read(query.toString()));
+        bytes += Buffer.byteLength(JSON.stringify(page), 'utf8');
+        if (bytes > 16_000_000)
+            throw new Error('Managed Agents transcript limit exceeded');
+        for (const e of page.data)
+            events.set(e.id, e);
+        if (events.size > 10_000)
+            throw new Error('Managed Agents event limit exceeded');
+        if (!page.next_page)
+            return [...events.values()];
+        if (cursors.has(page.next_page))
+            throw new Error('Repeated Managed Agents cursor');
+        cursors.add(page.next_page);
+        cursor = page.next_page;
+    }
+    throw new Error('Managed Agents page limit exceeded');
+}
+/** Incremental reducer. Provider completion is always unverified. */
+export class ManagedProgress {
+    seen = new Set();
+    text = [];
+    tools = [];
+    runs = new Map();
+    failures = 0;
+    status = 'unknown';
+    stopReason = null;
+    cost = null;
+    since;
+    bytes = 0;
+    finished = false;
+    interrupted = false;
+    accept(events) {
+        for (const e of events) {
+            // Queued user messages may be returned again after processing.
+            if (!e.processed_at)
+                continue;
+            if (this.seen.has(e.id))
+                continue;
+            if (this.seen.size >= 10_000)
+                throw new Error('Managed Agents event limit exceeded');
+            this.bytes += Buffer.byteLength(JSON.stringify(e), 'utf8');
+            if (this.bytes > 16_000_000)
+                throw new Error('Managed Agents transcript limit exceeded');
+            this.seen.add(e.id);
+            if (!this.since || e.processed_at > this.since)
+                this.since = e.processed_at;
+            if (e.type === 'user.message') {
+                this.finished = false;
+                this.interrupted = false;
+            }
+            else if (e.type === 'user.interrupt') {
+                this.finished = false;
+                this.interrupted = true;
+            }
+            else if (e.type === 'agent.message' && Array.isArray(e.content)) {
+                this.text.push(e.content.filter(b => b?.type === 'text' && typeof b.text === 'string').map(b => b.text).join(''));
+            }
+            else if (e.type === 'agent.tool_use' || e.type === 'agent.mcp_tool_use') {
+                this.tools.push({ name: e.name ?? '?', input: e.input });
+            }
+            else if (e.type === 'session.status_running') {
+                this.status = 'running';
+                this.stopReason = null;
+                this.finished = false;
+            }
+            else if (e.type === 'session.status_idle') {
+                this.status = 'idle';
+                this.stopReason = e.stop_reason?.type ?? null;
+                this.finished = this.stopReason === 'end_turn' && !this.interrupted && [...this.runs.values()].every(r => r.status === 'ended');
+            }
+            else if (e.type === 'session.status_terminated') {
+                this.status = 'terminated';
+                this.finished = false;
+            }
+            else if (e.type === 'session.error' || e.type === 'session.status_error' || e.type === 'session.status_failed') {
+                this.failures++;
+            }
+            else if (e.type === 'session.usage') {
+                this.cost = e.usage && typeof e.usage === 'object' ? e.usage.list_cost ?? null : null;
+            }
+            if (e.type === 'workflow_run.error')
+                this.failures++;
+            if (e.workflow_run_id && e.type.startsWith('workflow_run.')) {
+                this.finished = false;
+                const run = this.runs.get(e.workflow_run_id) ?? { id: e.workflow_run_id, status: 'running' };
+                if (e.type === 'workflow_run.status_ended') {
+                    run.status = 'ended';
+                    run.result = typeof e.result === 'object' ? e.result.type : 'unknown';
+                    if (run.result !== 'completed')
+                        this.failures++;
+                }
+                else if (e.type === 'workflow_run.status_idle' && run.status !== 'ended')
+                    run.status = 'idle';
+                else if (e.type === 'workflow_run.status_running' && run.status !== 'ended')
+                    run.status = 'running';
+                this.runs.set(run.id, run);
+            }
+        }
+    }
+    watermark() { return this.since; }
+    snapshot() {
+        const workflowRuns = [...this.runs.values()].map(r => ({ ...r }));
+        const openRuns = workflowRuns.filter(r => r.status !== 'ended').length;
+        const blocked = this.status === 'idle' && ['budget_reached', 'requires_action'].includes(this.stopReason ?? '');
+        return {
+            assistantText: this.text.join(''), toolUses: [...this.tools], status: this.status,
+            stopReason: this.stopReason, eventCount: this.seen.size, workflowRuns, openRuns,
+            finished: this.finished, interrupted: this.interrupted, blocked, observedFailures: this.failures, listCost: this.cost,
+            verification: 'unverified',
+            needsThreadInspection: workflowRuns.length > 0,
+        };
+    }
+}
+/** Build only the supported configuration; do not pass arbitrary multiagent JSON. */
+export function dynamicConfig(input) {
+    if (input.dynamicWorkflows !== undefined && typeof input.dynamicWorkflows !== 'boolean')
+        throw new Error('dynamicWorkflows must be boolean');
+    const enabled = input.dynamicWorkflows === true;
+    if (input.budgetCents !== undefined || enabled) {
+        if (typeof input.budgetCents !== 'string' || !/^[1-9][0-9]{0,8}$/.test(input.budgetCents)) {
+            throw new Error('budgetCents must be a positive integer cents string (maximum 999999999)');
+        }
+    }
+    if (enabled && input.networking !== undefined && input.networking !== 'limited')
+        throw new Error('Dynamic workflows require limited networking');
+    const hosts = input.allowedHosts ?? [];
+    if (!Array.isArray(hosts) || hosts.length > 100 || hosts.some(h => typeof h !== 'string' || h.length > 253 || !/^[a-z0-9]+(?:[.-][a-z0-9]+)*$/i.test(h))) {
+        throw new Error('allowedHosts must contain at most 100 exact hostnames');
+    }
+    const agents = input.predefinedAgents;
+    if (agents !== undefined && (!Array.isArray(agents) || agents.length < 1 || agents.length > 20 || agents.some(a => typeof a !== 'string' || !/^agent_[A-Za-z0-9]+$/.test(a)))) {
+        throw new Error('predefinedAgents must contain 1 to 20 agent IDs');
+    }
+    return {
+        enabled,
+        budget: input.budgetCents === undefined ? undefined : { type: 'limit', max_list_cost: { amount: input.budgetCents, currency: 'USD' } },
+        multiagent: enabled ? {
+            type: 'multiagent_20261001', subagents: { type: 'disabled' },
+            workflows: { type: 'enabled', ...(agents ? { inline_agents: { type: 'disabled' }, predefined_agents: agents } : {}) },
+        } : undefined,
+        networking: enabled || input.networking === 'limited' ? { type: 'limited', allowed_hosts: hosts } : { type: input.networking ?? 'unrestricted' },
+    };
+}
+//# sourceMappingURL=managed-workflows.js.map

package/v3/@claude-flow/cli/dist/src/services/worker-daemon.d.ts

@@ -90,6 +90,7 @@ export declare class WorkerDaemon extends EventEmitter {
     private headlessInitPromise;
     private originalConfig?;
     private fileConfigResourceThresholds?;
+    private fileConfigScalars?;
     private gitIdentity;
     private lastSupervisorRenewalMs;
     constructor(projectRoot: string, config?: Partial<DaemonConfig>);