@modelprofile.com/flexharness 10.24.0 → 10.24.1

package/dist_ts/classes.flexharness.slashcommands.js

@@ -0,0 +1,458 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessAbortError, FlexHarnessSessionBusyError, FlexHarnessSlashCommandReentryError, FlexHarnessSlashCommandUnavailableError, FlexHarnessValidationError, } from './errors.js';
+import { normalizeJsonValue } from './utils.json.js';
+import { normalizeFlexPrompt } from './utils.prompt.js';
+import { FLEX_SLASH_COMMAND_INITIALIZE_TEMPLATE, expandSlashCommandTemplate, isReservedSlashCommandName, parseSlashCommand, slashCommandTemplateHints, } from './utils.slashcommands.js';
+import { publicSnapshot } from './utils.transfer.js';
+import { validateSlashCommandExecutionOptions } from './utils.validation.js';
+import { slashCommandSessionUnavailableReason, requireSessionGeneration, } from './utils.flexharness.js';
+const importedSessionUnavailableReason = 'Session is an imported conversation and is read-only.';
+/** Slash command listing and execution, and the ownership of their activity. */
+export class FlexHarnessSlashCommands {
+    core;
+    activeSlashCommandExecutions = new Map();
+    activeSlashCommandListings = new Set();
+    slashCommandInvocationContext = new plugins.AsyncLocalStorage();
+    slashCommandActivityContext = new plugins.AsyncLocalStorage();
+    constructor(core) {
+        this.core = core;
+    }
+    async listSlashCommands(scopeId, sessionId) {
+        const { scope, state } = await this.core.resolveState(scopeId);
+        return this.trackSlashCommandListing(scopeId, state, sessionId, async (signal) => {
+            await this.core.reversions.awaitReversionOperation(state.scopeQueue, signal);
+            signal.throwIfAborted();
+            this.core.assertStateAcceptingWork(state);
+            const stored = this.core.requireSession(state, sessionId);
+            const configuration = await this.core.configurations.resolveSessionConfiguration(scopeId, scope.scope, state, stored, signal);
+            await this.core.reversions.reconcileContextAvailability(state, stored);
+            signal.throwIfAborted();
+            const sessionAvailable = this.isSessionAvailableForSlashCommand(state, stored);
+            const reversionIdleReason = await this.core.reversions.reversionUnavailableReason(state, stored, false, signal);
+            signal.throwIfAborted();
+            const descriptors = this.createSlashCommandDescriptors(state, stored, sessionAvailable, reversionIdleReason, configuration.slashCommands);
+            if (stored.session.origin === undefined)
+                return descriptors;
+            return publicSnapshot(descriptors.map((descriptor) => ({
+                ...descriptor,
+                available: false,
+                unavailableReason: importedSessionUnavailableReason,
+            })));
+        });
+    }
+    createSlashCommandDescriptors(state, stored, sessionAvailable, reversionIdleReason, slashCommands = this.core.slashCommands) {
+        const sessionAvailability = sessionAvailable
+            ? {}
+            : { available: false, unavailableReason: slashCommandSessionUnavailableReason };
+        const undoUnit = this.core.reversions.reversionUnit(stored, 'undo');
+        const redoUnit = this.core.reversions.reversionUnit(stored, 'redo');
+        const workspaceReversion = (unit) => !unit
+            || !this.core.turnReversionProvider
+            || unit.segments.some((segment) => segment.provenance !== 'workspace')
+            ? 'unsupported'
+            : 'supported';
+        const reversionAvailability = (unit) => {
+            if (reversionIdleReason)
+                return {
+                    available: false,
+                    unavailableReason: reversionIdleReason,
+                };
+            if (!unit)
+                return { available: false, unavailableReason: 'No turn is available.' };
+            if (!unit.target.contextAvailable)
+                return {
+                    available: false,
+                    unavailableReason: 'The turn is beyond the context archive horizon.',
+                };
+            if (unit.segments.some((segment) => segment.disposition === 'revertible' && segment.workspaceReference === undefined))
+                return {
+                    available: false,
+                    unavailableReason: 'The turn has no available workspace reversion capture.',
+                };
+            return { available: true };
+        };
+        const compactAvailable = Boolean(this.core.agentSessionPolicy.contextCompactor) && sessionAvailable;
+        const compactUnavailableReason = !this.core.agentSessionPolicy.contextCompactor
+            ? 'No context compactor is configured.'
+            : !sessionAvailable
+                ? slashCommandSessionUnavailableReason
+                : undefined;
+        const initPrompt = expandSlashCommandTemplate(FLEX_SLASH_COMMAND_INITIALIZE_TEMPLATE, '', []);
+        const initAvailability = this.slashCommandPromptAvailability(state, stored, this.core.prompts.promptAdmissionByteSize(initPrompt, {}));
+        const descriptors = [
+            {
+                name: 'compact',
+                description: 'Compact the current session context.',
+                kind: 'builtin',
+                hints: [],
+                available: compactAvailable,
+                ...(compactUnavailableReason === undefined
+                    ? {}
+                    : { unavailableReason: compactUnavailableReason }),
+                workspaceReversion: 'not-applicable',
+            },
+            {
+                name: 'init',
+                description: 'Create or update AGENTS.md for the active workspace.',
+                kind: 'builtin',
+                hints: ['$ARGUMENTS'],
+                ...initAvailability,
+                workspaceReversion: 'not-applicable',
+            },
+            {
+                name: 'undo',
+                description: 'Undo the most recent session operation.',
+                kind: 'builtin',
+                hints: [],
+                ...reversionAvailability(undoUnit),
+                workspaceReversion: workspaceReversion(undoUnit),
+            },
+            {
+                name: 'redo',
+                description: 'Redo the most recently undone session operation.',
+                kind: 'builtin',
+                hints: [],
+                ...reversionAvailability(redoUnit),
+                workspaceReversion: workspaceReversion(redoUnit),
+            },
+        ];
+        for (const registration of slashCommands.values()) {
+            const template = typeof registration.template === 'string';
+            const availability = template
+                ? this.slashCommandPromptAvailability(state, stored, this.core.prompts.promptAdmissionByteSize(expandSlashCommandTemplate(registration.template, '', []), {}))
+                : { available: sessionAvailable, ...sessionAvailability };
+            descriptors.push({
+                name: registration.name,
+                description: registration.description ?? '',
+                kind: template ? 'template' : 'handler',
+                hints: template ? slashCommandTemplateHints(registration.template) : [],
+                ...availability,
+                workspaceReversion: 'not-applicable',
+            });
+        }
+        return publicSnapshot(descriptors);
+    }
+    async executeSlashCommand(scopeId, sessionId, untouchedInput, options = {}) {
+        return this.executeSlashCommandInternal(scopeId, sessionId, untouchedInput, options, false);
+    }
+    async executeSessionSlashCommand(scopeId, sessionId, untouchedInput, options = {}) {
+        return this.executeSlashCommandInternal(scopeId, sessionId, untouchedInput, options, true);
+    }
+    async executeSlashCommandInternal(scopeId, sessionId, untouchedInput, options, sessionAware) {
+        const currentInvocation = this.slashCommandInvocationContext.getStore();
+        if (currentInvocation?.scopeId === scopeId && currentInvocation.sessionId === sessionId) {
+            throw this.core.trustInternalError(new FlexHarnessSlashCommandReentryError(sessionId));
+        }
+        const parsed = parseSlashCommand(untouchedInput);
+        if (parsed.type !== 'parsed')
+            return parsed;
+        let registration = sessionAware ? undefined : this.core.slashCommands.get(parsed.name);
+        if (!sessionAware && !isReservedSlashCommandName(parsed.name) && !registration) {
+            return Object.freeze({
+                type: 'unknown',
+                input: parsed.input,
+                name: parsed.name,
+                rawArguments: parsed.rawArguments,
+                arguments: parsed.arguments,
+            });
+        }
+        const promptOptions = validateSlashCommandExecutionOptions(options);
+        const { scope, state } = await this.core.resolveState(scopeId);
+        await state.scopeQueue;
+        this.core.assertOpen();
+        this.core.assertStateAcceptingWork(state);
+        const stored = this.core.requireSession(state, sessionId);
+        this.core.assertSessionWritable(stored);
+        if (sessionAware) {
+            const configuration = await this.core.configurations.resolveSessionConfiguration(scopeId, scope.scope, state, stored, options.signal);
+            this.core.assertStateAcceptingWork(state);
+            if (state.sessions.get(sessionId) !== stored) {
+                throw this.core.trustInternalError(new FlexHarnessAbortError('The session was deleted during slash command resolution.'));
+            }
+            registration = configuration.slashCommands.get(parsed.name);
+            if (!isReservedSlashCommandName(parsed.name) && !registration) {
+                return Object.freeze({
+                    type: 'unknown',
+                    input: parsed.input,
+                    name: parsed.name,
+                    rawArguments: parsed.rawArguments,
+                    arguments: parsed.arguments,
+                });
+            }
+        }
+        else if (stored.session.configurationRef !== undefined) {
+            throw new FlexHarnessValidationError('A bound session requires executeSessionSlashCommand().');
+        }
+        const sessionKey = this.slashCommandSessionKey(state.storageKey, sessionId);
+        const invocationOwner = this.slashCommandInvocationContext.getStore();
+        if (invocationOwner?.sessionKey === sessionKey) {
+            throw this.core.trustInternalError(new FlexHarnessSlashCommandReentryError(sessionId));
+        }
+        if (this.activeSlashCommandExecutions.has(sessionKey)) {
+            throw new FlexHarnessSessionBusyError(sessionId, 'already has an active slash command execution');
+        }
+        if (parsed.name === 'undo' || parsed.name === 'redo') {
+            if (parsed.arguments.length > 0) {
+                throw new FlexHarnessValidationError(`Slash command "/${parsed.name}" does not accept arguments.`);
+            }
+            await this.core.reversions.changeReversionCursorResolved(scopeId, sessionId, parsed.name, scope.scope, state, options.signal);
+            return Object.freeze({ type: 'operation', name: parsed.name });
+        }
+        if (parsed.name === 'compact') {
+            if (parsed.arguments.length > 0) {
+                throw new FlexHarnessValidationError('Slash command "/compact" does not accept arguments.');
+            }
+            const ignoredOption = ['system', 'maxSteps']
+                .find((key) => promptOptions[key] !== undefined);
+            if (ignoredOption) {
+                throw new FlexHarnessValidationError(`Slash command "/compact" does not support the "${ignoredOption}" option.`);
+            }
+            if (!this.core.agentSessionPolicy.contextCompactor) {
+                throw new FlexHarnessSlashCommandUnavailableError(parsed.name, 'No context compactor is configured.');
+            }
+            this.requireSessionAvailableForSlashCommand(state, stored, parsed.name);
+            return this.trackSlashCommandExecution(scopeId, state, sessionId, 'operation', options.signal, async (signal) => {
+                await this.core.reversions.commitRevertedBranch(state, stored, scopeId, scope.scope);
+                await this.core.compaction.compactStoredSession(scopeId, scope.scope, state, stored, promptOptions.modelHint, signal);
+                return Object.freeze({ type: 'operation', name: parsed.name });
+            });
+        }
+        if (options.signal?.aborted) {
+            throw this.core.trustInternalError(new FlexHarnessAbortError('The slash command was aborted.'));
+        }
+        if (parsed.name === 'init' || typeof registration?.template === 'string') {
+            const template = parsed.name === 'init'
+                ? FLEX_SLASH_COMMAND_INITIALIZE_TEMPLATE
+                : registration.template;
+            const expanded = expandSlashCommandTemplate(template, parsed.rawArguments, parsed.arguments);
+            normalizeFlexPrompt(expanded);
+            this.requireSlashCommandPromptAvailable(state, stored, parsed.name, this.core.prompts.promptAdmissionByteSize(expanded, promptOptions));
+            return this.trackSlashCommandExecution(scopeId, state, sessionId, 'prompt-admission', options.signal, async (signal) => {
+                const queued = await this.core.prompts.enqueuePromptInternal(scopeId, sessionId, expanded, promptOptions, undefined, undefined, undefined, signal, true);
+                const cancellation = this.core.trustInternalError(new FlexHarnessAbortError('The slash command prompt was aborted.'));
+                const cancel = () => {
+                    const entry = queued.queued;
+                    if (!entry)
+                        return;
+                    this.core.prompts.cancelQueuedPrompt(entry, cancellation, this.core.compaction.createCompactorContext(scopeId, scope.scope, state.storageKey, sessionId));
+                };
+                const cancellationSignals = options.signal && options.signal !== signal
+                    ? [signal, options.signal]
+                    : [signal];
+                for (const cancellationSignal of cancellationSignals) {
+                    cancellationSignal.addEventListener('abort', cancel, { once: true });
+                }
+                if (cancellationSignals.some((cancellationSignal) => cancellationSignal.aborted))
+                    cancel();
+                let admission;
+                try {
+                    admission = await queued.started;
+                    if (cancellationSignals.some((cancellationSignal) => cancellationSignal.aborted)) {
+                        cancel();
+                        throw cancellationSignals.find((cancellationSignal) => cancellationSignal.aborted)?.reason
+                            ?? cancellation;
+                    }
+                }
+                catch (error) {
+                    for (const cancellationSignal of cancellationSignals) {
+                        cancellationSignal.removeEventListener('abort', cancel);
+                    }
+                    throw error;
+                }
+                void admission.completion.finally(() => {
+                    for (const cancellationSignal of cancellationSignals) {
+                        cancellationSignal.removeEventListener('abort', cancel);
+                    }
+                }).catch(() => undefined);
+                return Object.freeze({ type: 'prompt-admission', name: parsed.name, admission });
+            });
+        }
+        this.requireSessionAvailableForSlashCommand(state, stored, parsed.name);
+        return this.executeSlashCommandHandler(scopeId, scope.scope, state, stored, parsed.name, parsed.rawArguments, parsed.arguments, registration.handler, options.signal);
+    }
+    isSessionAvailableForSlashCommand(state, stored, allowPendingApply = false) {
+        return this.core.prompts.isSessionRuntimeIdle(state, stored)
+            && !this.activeSlashCommandExecutions.has(this.slashCommandSessionKey(state.storageKey, stored.session.sessionId))
+            && (stored.pendingReversion === undefined
+                || (allowPendingApply && stored.pendingReversion.kind === 'apply'));
+    }
+    slashCommandPromptUnavailableReason(state, stored, byteSize) {
+        if (state.lifecycle !== 'active')
+            return 'The session namespace is not accepting work.';
+        if (this.activeSlashCommandExecutions.has(this.slashCommandSessionKey(state.storageKey, stored.session.sessionId)))
+            return 'Session already has an active slash command execution.';
+        if (stored.pendingReversion)
+            return 'Session has a pending reversion operation.';
+        if (stored.session.agent !== undefined) {
+            return 'Subagent sessions can only be prompted through the foreground delegate tool.';
+        }
+        if (stored.outstandingPromptsById.size >= this.core.promptQueueLimits.maxOutstandingPromptsPerSession) {
+            return 'Session has reached its outstanding prompt limit.';
+        }
+        if (stored.outstandingPromptBytes + byteSize > this.core.promptQueueLimits.maxOutstandingBytesPerSession) {
+            return 'Session has reached its outstanding prompt byte limit.';
+        }
+        if (this.core.prompts.pendingPromptAdmissions >= this.core.promptQueueLimits.maxPendingAdmissions) {
+            return 'FlexHarness has reached its pending prompt admission limit.';
+        }
+        if (this.core.prompts.pendingPromptAdmissionBytes + byteSize > this.core.promptQueueLimits.maxPendingAdmissionBytes) {
+            return 'FlexHarness has reached its pending prompt admission byte limit.';
+        }
+        return undefined;
+    }
+    slashCommandPromptAvailability(state, stored, byteSize) {
+        const unavailableReason = this.slashCommandPromptUnavailableReason(state, stored, byteSize);
+        return unavailableReason === undefined
+            ? { available: true }
+            : { available: false, unavailableReason };
+    }
+    requireSlashCommandPromptAvailable(state, stored, commandName, byteSize) {
+        const reason = this.slashCommandPromptUnavailableReason(state, stored, byteSize);
+        if (reason)
+            throw new FlexHarnessSlashCommandUnavailableError(commandName, reason);
+    }
+    slashCommandSessionKey(storageKey, sessionId) {
+        return JSON.stringify([storageKey, sessionId]);
+    }
+    requireSessionAvailableForSlashCommand(state, stored, commandName) {
+        if (!this.isSessionAvailableForSlashCommand(state, stored)) {
+            throw new FlexHarnessSlashCommandUnavailableError(commandName, slashCommandSessionUnavailableReason);
+        }
+    }
+    trackSlashCommandExecution(scopeId, state, sessionId, kind, externalSignal, operation) {
+        const sessionKey = this.slashCommandSessionKey(state.storageKey, sessionId);
+        if (this.activeSlashCommandExecutions.has(sessionKey)) {
+            throw new FlexHarnessSessionBusyError(sessionId, 'already has an active slash command execution');
+        }
+        const controller = new AbortController();
+        const abortFromExternalSignal = () => {
+            if (!controller.signal.aborted) {
+                controller.abort(this.core.trustInternalError(new FlexHarnessAbortError('The slash command was aborted.')));
+            }
+        };
+        externalSignal?.addEventListener('abort', abortFromExternalSignal, { once: true });
+        if (externalSignal?.aborted)
+            abortFromExternalSignal();
+        const activityOwner = Object.freeze({ scopeId, storageKey: state.storageKey, sessionId });
+        const completion = Promise.resolve().then(() => this.slashCommandActivityContext.run(activityOwner, () => {
+            if (controller.signal.aborted)
+                throw controller.signal.reason;
+            return operation(controller.signal);
+        }));
+        const active = {
+            kind,
+            storageKey: state.storageKey,
+            sessionId,
+            controller,
+            completion,
+        };
+        this.activeSlashCommandExecutions.set(sessionKey, active);
+        return completion.finally(() => {
+            externalSignal?.removeEventListener('abort', abortFromExternalSignal);
+            if (this.activeSlashCommandExecutions.get(sessionKey) === active) {
+                this.activeSlashCommandExecutions.delete(sessionKey);
+            }
+        });
+    }
+    trackSlashCommandListing(scopeId, state, sessionId, operation) {
+        const controller = new AbortController();
+        const activityOwner = Object.freeze({ scopeId, storageKey: state.storageKey, sessionId });
+        const completion = Promise.resolve().then(() => this.slashCommandActivityContext.run(activityOwner, () => operation(controller.signal)));
+        const active = {
+            storageKey: state.storageKey,
+            sessionId,
+            controller,
+            completion,
+        };
+        this.activeSlashCommandListings.add(active);
+        return completion.finally(() => {
+            this.activeSlashCommandListings.delete(active);
+        });
+    }
+    async executeSlashCommandHandler(scopeId, scope, state, stored, commandName, rawArguments, arguments_, handler, externalSignal) {
+        const sessionKey = this.slashCommandSessionKey(state.storageKey, stored.session.sessionId);
+        const invocationOwner = this.slashCommandInvocationContext.getStore();
+        if (invocationOwner?.sessionKey === sessionKey) {
+            throw this.core.trustInternalError(new FlexHarnessSlashCommandReentryError(stored.session.sessionId));
+        }
+        if (this.activeSlashCommandExecutions.has(sessionKey)) {
+            throw new FlexHarnessSessionBusyError(stored.session.sessionId, 'already has an active slash command execution');
+        }
+        const owner = Object.freeze({
+            scopeId,
+            storageKey: state.storageKey,
+            sessionId: stored.session.sessionId,
+            sessionKey,
+        });
+        return this.trackSlashCommandExecution(scopeId, state, stored.session.sessionId, 'handler', externalSignal, (signal) => this.slashCommandInvocationContext.run(owner, async () => {
+            const context = Object.freeze({
+                scopeId,
+                scope,
+                storageKey: state.storageKey,
+                sessionId: stored.session.sessionId,
+                ...requireSessionGeneration(stored.session),
+                rawArguments,
+                arguments: arguments_,
+                signal,
+            });
+            try {
+                await this.core.reversions.commitRevertedBranch(state, stored, scopeId, scope);
+                const result = await handler(context);
+                return Object.freeze({
+                    type: 'handler-result',
+                    name: commandName,
+                    result: normalizeJsonValue(result === undefined ? null : result, this.core.toolOutputLimits),
+                });
+            }
+            catch (error) {
+                throw this.core.projectOperationError(error, 'slashCommand', scopeId, stored.session.sessionId, `slash-command:${commandName}`);
+            }
+        }));
+    }
+    async abortSlashCommandExecutions(storageKey, reason, errors, sessionId) {
+        const active = [...this.activeSlashCommandExecutions.values()]
+            .filter((execution) => (storageKey === undefined || execution.storageKey === storageKey)
+            && (sessionId === undefined || execution.sessionId === sessionId));
+        for (const execution of active) {
+            if (!execution.controller.signal.aborted)
+                execution.controller.abort(reason);
+        }
+        const awaited = active.filter((execution) => execution.kind !== 'prompt-admission');
+        const results = await Promise.allSettled(awaited.map((execution) => execution.completion));
+        for (let index = 0; index < results.length; index++) {
+            const result = results[index];
+            if (result.status === 'rejected' && awaited[index].kind === 'handler') {
+                this.core.appendUnexpectedErrors(errors, result.reason);
+            }
+        }
+    }
+    abortSlashCommandListings(storageKey, reason, sessionId) {
+        const active = [...this.activeSlashCommandListings]
+            .filter((listing) => (storageKey === undefined || listing.storageKey === storageKey)
+            && (sessionId === undefined || listing.sessionId === sessionId));
+        if (active.length === 0)
+            return undefined;
+        for (const listing of active) {
+            if (!listing.controller.signal.aborted)
+                listing.controller.abort(reason);
+        }
+        return Promise.allSettled(active.map((listing) => listing.completion)).then(() => undefined);
+    }
+    ambientSlashCommandOwner(criteria = {}) {
+        const matches = (owner) => ((criteria.scopeId === undefined || owner.scopeId === criteria.scopeId)
+            && (criteria.storageKey === undefined || owner.storageKey === criteria.storageKey)
+            && (criteria.sessionId === undefined || owner.sessionId === criteria.sessionId));
+        const invocationOwner = this.slashCommandInvocationContext.getStore();
+        if (invocationOwner && matches(invocationOwner))
+            return invocationOwner;
+        const activityOwner = this.slashCommandActivityContext.getStore();
+        return activityOwner && matches(activityOwner) ? activityOwner : undefined;
+    }
+    assertNoAmbientSlashCommandTeardown(criteria = {}) {
+        const owner = this.ambientSlashCommandOwner(criteria);
+        if (owner) {
+            throw this.core.trustInternalError(new FlexHarnessSlashCommandReentryError(owner.sessionId));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexharness.slashcommands.js","sourceRoot":"","sources":["../ts/classes.flexharness.slashcommands.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.flexharness.subagents.d.ts

@@ -0,0 +1,31 @@
+import type { IFlexBackgroundExecution, IFlexSteerAdmission, IFlexSteerInput, IFlexSession, IFlexSubagentProvenance } from './interfaces.js';
+import type { IStorageState, IActiveRun } from './interfaces.flexharness.js';
+import type { FlexHarnessCore } from './classes.flexharness.core.js';
+/** Subagent tasks: delegation tools, child sessions, task input and background executions. */
+export declare class FlexHarnessSubagents<TScope> {
+    private readonly core;
+    constructor(core: FlexHarnessCore<TScope>);
+    sendSubagentInput(scopeId: string, parentSessionId: string, parentRunId: string, taskId: string, steer: IFlexSteerInput): Promise<IFlexSteerAdmission>;
+    private sendSubagentInputInRun;
+    /** Fences live ownership by exact runtime pointers and admission seeds all the way to root. */
+    private assertLiveSubagentOwnership;
+    listBackgroundExecutions(scopeId: string, sessionId: string): Promise<IFlexBackgroundExecution[]>;
+    getBackgroundExecution(scopeId: string, sessionId: string, executionId: string): Promise<IFlexBackgroundExecution>;
+    abortBackgroundExecution(scopeId: string, sessionId: string, executionId: string): Promise<void>;
+    /**
+     * Holds the end of a run's generation until one more of its background subagents settles. The
+     * subagent commits its result to the generation before it settles, so the model takes the result
+     * in with another step instead of the run ending without it. The engine bounds the scoped
+     * wait from its observed dispatch and commits timer check-ins. Returns at once when none runs.
+     */
+    awaitNextBackgroundSubagent(run: IActiveRun, signal: AbortSignal): Promise<void>;
+    createSubagentProvenance(state: IStorageState, session: Readonly<IFlexSession>): Readonly<IFlexSubagentProvenance> | undefined;
+    createSubagentTool(run: IActiveRun): unknown;
+    private executeSubagentTask;
+    createSubagentSendTool(run: IActiveRun): unknown;
+    createSubagentResultTool(run: IActiveRun): unknown;
+    private acquireSubagentSession;
+    private createSubagentSessionId;
+    private updateSubagentToolPart;
+    private projectBackgroundExecution;
+}