vgxness 1.20.4 → 1.20.6

package/dist/agents/agent-activation-service.js

@@ -1,263 +1 @@
-import { responseByteAccounting, summarizePayloadContent } from '../payload/payload-summary.js';
-import { resolveAgentProfileModel } from './profile-model-routing.js';
-const defaultAgentName = 'vgxness-manager';
-const provider = 'opencode';
-const nextSafeAction = 'review_provider_payload_and_choose_manual_handoff';
-const safety = { executesProvider: false, writesProviderConfig: false, backgroundWorker: false, autonomy: false };
-export class AgentActivationService {
-    dependencies;
-    constructor(dependencies) {
-        this.dependencies = dependencies;
-    }
-    activate(input) {
-        const validated = validateActivationInput(input);
-        if (!validated.ok)
-            return validated;
-        const agent = this.resolveAgent(validated.value);
-        if (!agent.ok)
-            return agent;
-        if (agent.value.mode !== 'agent')
-            return validationFailure('Agent activation requires a top-level agent');
-        const selection = resolveAgentProfileModel({
-            agent: agent.value,
-            ...(validated.value.providerAdapter === undefined ? {} : { providerAdapter: validated.value.providerAdapter }),
-        });
-        if (!selection.ok)
-            return selection;
-        if (selection.value.providerAdapter !== provider)
-            return validationFailure(`Provider adapter is not supported for activation: ${selection.value.providerAdapter}`);
-        const run = this.dependencies.runs.createRun({
-            project: validated.value.project,
-            userIntent: validated.value.userIntent,
-            workflow: validated.value.workflow,
-            phase: validated.value.phase,
-            selectedAgentId: agent.value.id,
-            providerAdapter: selection.value.providerAdapter,
-            model: selection.value.model,
-        });
-        if (!run.ok)
-            return run;
-        const payloadMode = resolvePayloadMode(validated.value);
-        const payload = this.dependencies.opencodeManagerPayload.build(toPayloadInput(validated.value, agent.value.id, payloadMode));
-        if (!payload.ok)
-            return this.failAfterRun(run.value.id, payload.error.code, payload.error.message);
-        const verboseEnvelopeWithoutRun = {
-            version: 1,
-            agent: { id: agent.value.id, name: agent.value.name, scope: agent.value.scope, mode: 'agent' },
-            provider,
-            modelSelection: selection.value,
-            providerPayload: payload.value,
-            ...(payload.value.skillPayload !== undefined ? { skillsContext: payload.value.skillPayload } : {}),
-            nextSafeAction,
-            safety,
-            warnings: [
-                'Agent activation prepared a provider-ready payload but does not execute providers.',
-                'No provider configuration, background worker, autonomous step, or secrets expansion was performed.',
-                ...selection.value.warnings,
-                ...payload.value.warnings,
-            ],
-        };
-        const envelopeWithoutRun = payloadMode === 'compact' ? compactActivationEnvelope(verboseEnvelopeWithoutRun, validated.value) : verboseEnvelopeWithoutRun;
-        const checkpoint = this.dependencies.runs.appendCheckpoint({
-            runId: run.value.id,
-            label: 'agent-activation-initial',
-            state: toJson(checkpointState(envelopeWithoutRun, run.value.id, payloadMode)),
-        });
-        if (!checkpoint.ok)
-            return this.failAfterRun(run.value.id, checkpoint.error.code, checkpoint.error.message);
-        const event = this.dependencies.runs.appendEvent({
-            runId: run.value.id,
-            kind: 'timeline',
-            title: 'Agent activation prepared',
-            payload: toJson({
-                agent: envelopeWithoutRun.agent,
-                provider,
-                modelSelection: selection.value,
-                nextSafeAction,
-                safety,
-                checkpointId: checkpoint.value.id,
-            }),
-            relatedType: 'run-checkpoint',
-            relatedId: checkpoint.value.id,
-        });
-        if (!event.ok)
-            return this.failAfterRun(run.value.id, event.error.code, event.error.message);
-        return ok({ ...envelopeWithoutRun, run: { id: run.value.id, status: 'created', checkpointId: checkpoint.value.id } });
-    }
-    resolveAgent(input) {
-        if (input.agentId !== undefined)
-            return this.dependencies.agents.getAgent(input.agentId);
-        if (this.dependencies.managerProfiles !== undefined) {
-            const effective = this.dependencies.managerProfiles.resolveEffectiveManager({
-                project: input.project,
-                scope: input.scope,
-                managerName: defaultAgentName,
-            });
-            return effective.ok ? ok(effective.value.manager) : effective;
-        }
-        return this.dependencies.agents.getAgentByName(input.project, input.scope, defaultAgentName);
-    }
-    failAfterRun(runId, code, message) {
-        const nestedFailures = [];
-        const eventResult = this.dependencies.runs.appendEvent({
-            runId,
-            kind: 'timeline',
-            title: 'Agent activation failed',
-            payload: toJson({ error: { code: String(code), message }, nextSafeActionReturned: false }),
-        });
-        if (!eventResult.ok) {
-            nestedFailures.push({ step: 'append-event', code: String(eventResult.error.code), message: eventResult.error.message });
-        }
-        const finalStatusResult = this.dependencies.runs.updateFinalStatus({ runId, status: 'failed', outcome: 'failure', outcomeReason: message });
-        if (!finalStatusResult.ok) {
-            nestedFailures.push({ step: 'update-final-status', code: String(finalStatusResult.error.code), message: finalStatusResult.error.message });
-        }
-        return nestedFailures.length === 0
-            ? { ok: false, error: { code, message } }
-            : { ok: false, error: { code, message, cause: { nestedFailures } } };
-    }
-}
-function validateActivationInput(input) {
-    if (input.project.trim().length === 0)
-        return validationFailure('Project is required');
-    if (input.userIntent.trim().length === 0)
-        return validationFailure('userIntent is required');
-    if (input.agentId !== undefined && input.agentId.trim().length === 0)
-        return validationFailure('agentId must not be empty');
-    if (input.payloadMode !== undefined && input.payloadMode !== 'compact' && input.payloadMode !== 'verbose')
-        return validationFailure('payloadMode must be compact or verbose');
-    const validated = {
-        project: input.project.trim(),
-        scope: input.scope ?? 'project',
-        userIntent: input.userIntent.trim(),
-        workflow: input.workflow?.trim() || 'agent-activation',
-        phase: input.phase?.trim() || 'activation',
-    };
-    if (input.agentId !== undefined)
-        validated.agentId = input.agentId.trim();
-    if (input.workspaceRoot !== undefined)
-        validated.workspaceRoot = input.workspaceRoot;
-    if (input.maxSourceBytes !== undefined)
-        validated.maxSourceBytes = input.maxSourceBytes;
-    if (input.providerAdapter !== undefined) {
-        if (input.providerAdapter.trim().length === 0)
-            return validationFailure('providerAdapter must not be empty');
-        validated.providerAdapter = input.providerAdapter.trim();
-    }
-    if (input.payloadMode !== undefined)
-        validated.payloadMode = input.payloadMode;
-    return ok(validated);
-}
-function resolvePayloadMode(input) {
-    return input.payloadMode ?? 'compact';
-}
-function toPayloadInput(input, agentId, payloadMode) {
-    const payload = { project: input.project, scope: input.scope };
-    if (input.agentId !== undefined)
-        payload.agentId = agentId;
-    else
-        payload.useManagerOverlay = true;
-    if (input.workspaceRoot !== undefined)
-        payload.workspaceRoot = input.workspaceRoot;
-    if (input.maxSourceBytes !== undefined)
-        payload.maxSourceBytes = input.maxSourceBytes;
-    payload.payloadMode = payloadMode;
-    return payload;
-}
-function checkpointState(envelopeWithoutRun, runId, mode) {
-    const base = { ...envelopeWithoutRun, run: { id: runId, status: 'created', checkpointId: null } };
-    if (mode === 'verbose')
-        return toJson(base);
-    return toJson({
-        version: base.version,
-        run: base.run,
-        agent: base.agent,
-        provider: base.provider,
-        modelSelection: base.modelSelection,
-        providerPayload: {
-            version: base.providerPayload.version,
-            provider: base.providerPayload.provider,
-            payloadMode: base.providerPayload.payloadMode,
-            selection: base.providerPayload.selection,
-            providerArtifacts: base.providerPayload.providerArtifacts,
-            skillDiagnostics: base.providerPayload.skillDiagnostics,
-            safety: base.providerPayload.safety,
-            warnings: base.providerPayload.warnings,
-        },
-        skillsContext: base.skillsContext === undefined
-            ? undefined
-            : {
-                version: base.skillsContext.version,
-                providerAgnostic: base.skillsContext.providerAgnostic,
-                context: base.skillsContext.context,
-                itemCount: base.skillsContext.items.length,
-                skipped: base.skillsContext.skipped,
-                skillDiagnostics: base.skillsContext.skillDiagnostics,
-                warnings: base.skillsContext.warnings,
-            },
-        nextSafeAction: base.nextSafeAction,
-        safety: base.safety,
-        warnings: base.warnings,
-    });
-}
-function compactActivationEnvelope(verbose, input) {
-    const compactProviderPayload = {
-        version: verbose.providerPayload.version,
-        provider: verbose.providerPayload.provider,
-        payloadMode: 'compact',
-        installable: verbose.providerPayload.installable,
-        selection: verbose.providerPayload.selection,
-        providerArtifacts: verbose.providerPayload.providerArtifacts,
-        ...(verbose.providerPayload.skillDiagnostics === undefined ? {} : { skillDiagnostics: verbose.providerPayload.skillDiagnostics }),
-        safety: verbose.providerPayload.safety,
-        warnings: verbose.providerPayload.warnings,
-    };
-    const fullRetrieval = {
-        tool: 'vgxness_agent_activate',
-        payloadMode: 'verbose',
-        input: {
-            project: input.project,
-            scope: input.scope,
-            agentId: verbose.agent.id,
-            userIntent: input.userIntent,
-            workflow: input.workflow,
-            phase: input.phase,
-        },
-    };
-    const omittedSections = [];
-    if (verbose.providerPayload.skillPayload !== undefined)
-        omittedSections.push(omittedSection('providerPayload.skillPayload', 'Duplicate of skillsContext; omitted from compact activation response.', fullRetrieval, verbose.providerPayload.skillPayload));
-    if (verbose.skillsContext !== undefined)
-        omittedSections.push(omittedSection('skillsContext', 'Skill details remain durably retrievable through verbose activation or skill payload calls.', fullRetrieval, verbose.skillsContext));
-    const compact = {
-        version: verbose.version,
-        agent: verbose.agent,
-        provider: verbose.provider,
-        modelSelection: verbose.modelSelection,
-        providerPayload: compactProviderPayload,
-        omittedSections,
-        governanceConstraints: [
-            'Activation is preview-only and does not execute providers.',
-            'No provider configuration, background worker, autonomous step, or secrets expansion is performed.',
-            'Request payloadMode=verbose when full provider payload or skills context is needed.',
-        ],
-        nextSafeAction: verbose.nextSafeAction,
-        safety: verbose.safety,
-        warnings: verbose.warnings,
-    };
-    compact.responseByteAccounting = responseByteAccounting(verbose, compact);
-    return compact;
-}
-function omittedSection(path, reason, retrieval, value) {
-    const summary = summarizePayloadContent(JSON.stringify(value));
-    return { path, reason, hash: summary.contentHash, bytes: summary.contentBytes, retrieval };
-}
-function toJson(value) {
-    return JSON.parse(JSON.stringify(value));
-}
-function ok(value) {
-    return { ok: true, value };
-}
-function validationFailure(message) {
-    return { ok: false, error: { code: 'validation_failed', message } };
-}
+export * from '../application/agents/agent-activation-service.js';

package/dist/agents/agent-lookup-contexts.js

@@ -1,28 +1 @@
-export const GLOBAL_PERSONAL_AGENTS_PROJECT = '__personal__';
-export const GLOBAL_VGXNESS_AGENTS_PROJECT = '__vgxness__';
-export const LEGACY_VGXNESS_AGENTS_PROJECT = 'vgxness';
-export const agentLookupContexts = (project, scope) => {
-    const contexts = [{ project, scope }];
-    if (scope !== 'personal')
-        contexts.push({ project, scope: 'personal' });
-    if (project !== GLOBAL_PERSONAL_AGENTS_PROJECT)
-        contexts.push({ project: GLOBAL_PERSONAL_AGENTS_PROJECT, scope: 'personal' });
-    if (project !== GLOBAL_VGXNESS_AGENTS_PROJECT)
-        contexts.push({ project: GLOBAL_VGXNESS_AGENTS_PROJECT, scope: 'project' });
-    if (project !== LEGACY_VGXNESS_AGENTS_PROJECT)
-        contexts.push({ project: LEGACY_VGXNESS_AGENTS_PROJECT, scope: 'project' });
-    return dedupeContexts(contexts);
-};
-export const dedupeAgentLookupContexts = (contexts) => {
-    return dedupeContexts(contexts);
-};
-function dedupeContexts(contexts) {
-    const seen = new Set();
-    return contexts.filter((context) => {
-        const key = `${context.project}:${context.scope}`;
-        if (seen.has(key))
-            return false;
-        seen.add(key);
-        return true;
-    });
-}
+export * from '../application/agents/agent-lookup-contexts.js';

package/dist/agents/agent-registry-service.js

@@ -1,81 +1 @@
-import { agentLookupContexts } from './agent-lookup-contexts.js';
-import { AgentResolver } from './agent-resolver.js';
-import { AgentRepository } from './repositories/agents.js';
-export class AgentRegistryService {
-    database;
-    agents;
-    constructor(database) {
-        this.database = database;
-        this.agents = new AgentRepository(database);
-    }
-    registerAgent(input) {
-        return this.agents.register({ ...input, mode: 'agent' });
-    }
-    registerSubagent(input) {
-        return this.agents.register({ ...input, mode: 'subagent' });
-    }
-    getAgent(id) {
-        return this.agents.getById(id);
-    }
-    getAgentByName(project, scope, name) {
-        return this.agents.getByName(project, scope, name);
-    }
-    listAgents(filters = {}) {
-        return this.agents.list(filters);
-    }
-    listSubagents(parentAgentId) {
-        return this.agents.list({ mode: 'subagent', parentAgentId });
-    }
-    resolveAgents(input) {
-        return new AgentResolver(() => this.listAgentDefinitions(input)).resolve(input);
-    }
-    close() {
-        this.database.close();
-    }
-    listAgentDefinitions(input) {
-        if (input.project !== undefined)
-            return this.listAgentDefinitionsForContexts(input);
-        const filters = {};
-        if (input.scope !== undefined)
-            filters.scope = input.scope;
-        if (input.mode !== undefined)
-            filters.mode = input.mode;
-        const summaries = this.agents.list(filters);
-        if (!summaries.ok)
-            return summaries;
-        const definitions = [];
-        for (const summary of summaries.value) {
-            const agent = this.agents.getById(summary.id);
-            if (!agent.ok)
-                return agent;
-            definitions.push(agent.value);
-        }
-        return { ok: true, value: definitions };
-    }
-    listAgentDefinitionsForContexts(input) {
-        const project = input.project;
-        if (project === undefined)
-            return { ok: true, value: [] };
-        const summariesByName = new Map();
-        for (const context of agentLookupContexts(project, input.scope ?? 'project')) {
-            const filters = { project: context.project, scope: context.scope };
-            if (input.mode !== undefined)
-                filters.mode = input.mode;
-            const summaries = this.agents.list(filters);
-            if (!summaries.ok)
-                return summaries;
-            for (const summary of summaries.value) {
-                if (!summariesByName.has(summary.name))
-                    summariesByName.set(summary.name, summary);
-            }
-        }
-        const definitions = [];
-        for (const summary of summariesByName.values()) {
-            const agent = this.agents.getById(summary.id);
-            if (!agent.ok)
-                return agent;
-            definitions.push(agent.value);
-        }
-        return { ok: true, value: definitions };
-    }
-}
+export * from '../application/agents/agent-registry-service.js';

package/dist/agents/agent-resolver.js

@@ -1,287 +1 @@
-import { normalizeSddPhaseInput } from '../sdd/schema.js';
-import { agentLookupContexts } from './agent-lookup-contexts.js';
-export class AgentResolver {
-    loadAgents;
-    constructor(loadAgents) {
-        this.loadAgents = loadAgents;
-    }
-    resolve(input) {
-        const agents = this.loadAgents();
-        if (!agents.ok)
-            return agents;
-        const normalized = normalizeInput(input);
-        const candidates = [];
-        const skipped = [];
-        for (const agent of agents.value) {
-            const skipReasons = hardSkipReasons(agent, normalized);
-            if (skipReasons.length > 0) {
-                skipped.push(toSkipped(agent, skipReasons));
-                continue;
-            }
-            const scored = scoreAgent(agent, normalized);
-            if (scored.score <= 0) {
-                skipped.push(toSkipped(agent, ['no matching resolution signals']));
-                continue;
-            }
-            candidates.push(scored);
-        }
-        candidates.sort(compareCandidates);
-        skipped.sort(compareSkipped);
-        return ok({
-            context: {
-                ...(normalized.project !== undefined ? { project: normalized.project } : {}),
-                ...(normalized.scope !== undefined ? { scope: normalized.scope } : {}),
-                ...(normalized.taskDescription !== undefined ? { taskDescription: normalized.taskDescription } : {}),
-                ...(normalized.intent !== undefined ? { intent: normalized.intent } : {}),
-                desiredCapabilities: normalized.desiredCapabilities,
-                ...(normalized.workflow !== undefined ? { workflow: normalized.workflow } : {}),
-                ...(normalized.phase !== undefined ? { phase: normalized.phase } : {}),
-                ...(normalized.providerAdapter !== undefined ? { providerAdapter: normalized.providerAdapter } : {}),
-                ...(normalized.mode !== undefined ? { mode: normalized.mode } : {}),
-            },
-            candidates,
-            skipped,
-        });
-    }
-}
-const SDD_PHASE_SEMANTICS = [
-    {
-        name: 'sdd-planning',
-        phases: ['proposal', 'design', 'tasks'],
-        terms: ['plan', 'planning', 'proposal', 'propose', 'design', 'task', 'tasks', 'breakdown', 'slice', 'slicing'],
-    },
-    {
-        name: 'sdd-verification',
-        phases: ['verify'],
-        terms: ['verify', 'verification', 'test', 'testing', 'review', 'risk', 'evidence'],
-    },
-];
-function normalizeInput(input) {
-    const desiredCapabilities = normalizeList(input.desiredCapabilities ?? []);
-    const taskDescription = normalizeText(input.taskDescription);
-    const intent = normalizeText(input.intent);
-    const metaWorkflow = isMetaWorkflow(input.workflow);
-    const workflow = normalizeMetaWorkflow(input.workflow);
-    const phase = metaWorkflow || input.phase === undefined ? undefined : (isSddWorkflow(workflow) ? (normalizeSddPhaseInput(input.phase) ?? input.phase) : input.phase);
-    const { workflow: _workflow, phase: _phase, ...rest } = input;
-    return {
-        ...rest,
-        ...(workflow !== undefined ? { workflow } : {}),
-        ...(phase !== undefined ? { phase } : {}),
-        ...(taskDescription !== undefined ? { taskDescription } : {}),
-        ...(intent !== undefined ? { intent } : {}),
-        desiredCapabilities,
-        terms: tokenize([taskDescription, intent].filter((value) => value !== undefined).join(' ')),
-    };
-}
-function normalizeMetaWorkflow(workflow) {
-    if (isMetaWorkflow(workflow))
-        return undefined;
-    return workflow;
-}
-function isMetaWorkflow(workflow) {
-    return workflow?.trim().toLowerCase() === 'workflow-selection';
-}
-function hardSkipReasons(agent, input) {
-    const reasons = [];
-    if (input.project !== undefined && !agentMatchesRequestedContext(agent, input))
-        reasons.push(`context mismatch: ${agent.project}/${agent.scope}`);
-    else if (input.project === undefined && input.scope !== undefined && agent.scope !== input.scope)
-        reasons.push(`scope mismatch: ${agent.scope}`);
-    if (input.mode !== undefined && agent.mode !== input.mode)
-        reasons.push(`mode mismatch: ${agent.mode}`);
-    if (input.providerAdapter !== undefined && Object.keys(agent.adapters).length > 0 && agent.adapters[input.providerAdapter] === undefined)
-        reasons.push(`provider adapter mismatch: ${input.providerAdapter}`);
-    if ((input.workflow !== undefined || input.phase !== undefined) && agent.workflows.length > 0 && workflowMatches(agent, input).length === 0)
-        reasons.push('workflow mismatch');
-    if (input.desiredCapabilities.length > 0 && matchingValues(agent.capabilities, input.desiredCapabilities).length === 0)
-        reasons.push('capability mismatch');
-    return reasons;
-}
-function agentMatchesRequestedContext(agent, input) {
-    if (input.project === undefined)
-        return true;
-    const contexts = agentLookupContexts(input.project, input.scope ?? 'project');
-    return contexts.some((context) => agent.project === context.project && agent.scope === context.scope);
-}
-function scoreAgent(agent, input) {
-    const reasons = [];
-    let score = 0;
-    const capabilityMatches = matchingValues(agent.capabilities, input.desiredCapabilities);
-    if (capabilityMatches.length > 0) {
-        score += capabilityMatches.length * 30;
-        reasons.push(`capabilities matched: ${capabilityMatches.join(', ')}`);
-    }
-    const workflowMatchesValue = workflowSignalMatches(agent, input);
-    if (workflowMatchesValue.exactPhase.length > 0) {
-        score += workflowMatchesValue.exactPhase.length * 25;
-        reasons.push(`workflow phase matched: ${workflowMatchesValue.exactPhase.join(', ')}`);
-    }
-    if (workflowMatchesValue.phaseOnly.length > 0) {
-        score += workflowMatchesValue.phaseOnly.length * 22;
-        reasons.push(`workflow phase-only matched: ${workflowMatchesValue.phaseOnly.join(', ')}`);
-    }
-    if (workflowMatchesValue.broad.length > 0) {
-        score += workflowMatchesValue.broad.length * 20;
-        reasons.push(`workflow matched: ${workflowMatchesValue.broad.join(', ')}`);
-    }
-    if (input.providerAdapter !== undefined) {
-        if (agent.adapters[input.providerAdapter] !== undefined) {
-            score += 20;
-            reasons.push(`provider adapter matched: ${input.providerAdapter}`);
-        }
-        else if (Object.keys(agent.adapters).length === 0) {
-            score += 5;
-            reasons.push(`provider neutral: no adapter restrictions for ${input.providerAdapter}`);
-        }
-    }
-    const skillMatches = matchingValues(agent.skills, [...input.desiredCapabilities, ...input.terms]);
-    if (skillMatches.length > 0) {
-        score += skillMatches.length * 10;
-        reasons.push(`skills matched: ${skillMatches.join(', ')}`);
-    }
-    const textMatches = textSignalMatches(agent, input.terms);
-    if (textMatches.length > 0) {
-        score += Math.min(textMatches.length, 5) * 4;
-        reasons.push(`task text matched: ${textMatches.join(', ')}`);
-    }
-    const phaseSemanticMatches = phaseSemanticMatchesFor(agent, input);
-    for (const match of phaseSemanticMatches) {
-        score += 8;
-        reasons.push(`phase semantics matched: ${match}`);
-    }
-    if (input.mode !== undefined) {
-        score += 3;
-        reasons.push(`mode matched: ${agent.mode}`);
-    }
-    if (agent.mode === 'subagent') {
-        score += 2;
-        reasons.push(`parent constraint satisfied: ${agent.parentAgentId}`);
-    }
-    return { agent, score, reasons };
-}
-function workflowMatches(agent, input) {
-    const matches = workflowSignalMatches(agent, input);
-    return [...matches.broad, ...matches.phaseOnly, ...matches.exactPhase];
-}
-function workflowSignalMatches(agent, input) {
-    const requested = workflowRequestedSignals(input)
-        .filter((value) => value !== undefined)
-        .map(normalizeKey);
-    if (requested.length === 0)
-        return { broad: [], phaseOnly: [], exactPhase: [] };
-    const workflow = input.workflow !== undefined ? normalizeKey(input.workflow) : undefined;
-    const phase = input.phase !== undefined ? normalizeKey(input.phase) : undefined;
-    const exact = workflow !== undefined && phase !== undefined ? `${workflow}:${phase}` : undefined;
-    const matches = { broad: [], phaseOnly: [], exactPhase: [] };
-    for (const agentWorkflow of agent.workflows) {
-        const normalizedWorkflow = normalizeKey(agentWorkflow);
-        const comparableWorkflow = canonicalSddWorkflowTargetKey(agentWorkflow);
-        if (!requested.includes(normalizedWorkflow) && !requested.includes(comparableWorkflow) && !sddApplyAliasMatches(agentWorkflow, input))
-            continue;
-        if (exact !== undefined && (normalizedWorkflow === exact || comparableWorkflow === exact))
-            matches.exactPhase.push(agentWorkflow);
-        else if (phase !== undefined && normalizedWorkflow === phase)
-            matches.phaseOnly.push(agentWorkflow);
-        else if (sddApplyAliasMatches(agentWorkflow, input))
-            matches.exactPhase.push(agentWorkflow);
-        else
-            matches.broad.push(agentWorkflow);
-    }
-    return matches;
-}
-function canonicalSddWorkflowTargetKey(workflow) {
-    const normalized = normalizeKey(workflow);
-    const separator = normalized.indexOf(':');
-    if (separator <= 0)
-        return normalized;
-    const workflowName = normalized.slice(0, separator);
-    const phase = normalized.slice(separator + 1);
-    if (workflowName !== 'sdd')
-        return normalized;
-    return `${workflowName}:${normalizeSddPhaseInput(phase) ?? phase}`;
-}
-function workflowRequestedSignals(input) {
-    return [input.workflow, input.phase, input.workflow !== undefined && input.phase !== undefined ? `${input.workflow}:${input.phase}` : undefined];
-}
-function sddApplyAliasMatches(agentWorkflow, input) {
-    if (input.phase === undefined || normalizeKey(input.phase) !== 'apply')
-        return false;
-    if (input.workflow !== undefined && !isSddWorkflow(input.workflow))
-        return false;
-    return normalizeKey(agentWorkflow) === 'sdd:apply-progress';
-}
-function phaseSemanticMatchesFor(agent, input) {
-    const workflow = input.workflow !== undefined ? normalizeKey(input.workflow) : undefined;
-    if (workflow !== undefined && workflow !== 'sdd')
-        return [];
-    const inputPhase = input.phase !== undefined ? normalizeKey(input.phase) : undefined;
-    const agentTerms = tokenize([agent.name, agent.description, ...agent.capabilities, ...agent.skills, ...agent.workflows].join(' '));
-    const requestTerms = new Set(input.terms);
-    const matches = [];
-    for (const semantic of SDD_PHASE_SEMANTICS) {
-        const phaseMatches = inputPhase !== undefined && semantic.phases.includes(inputPhase);
-        const termMatches = semantic.terms.some((term) => requestTerms.has(term));
-        const agentMatches = semantic.terms.some((term) => agentTerms.includes(term));
-        if ((phaseMatches || termMatches) && agentMatches)
-            matches.push(semantic.name);
-    }
-    return matches;
-}
-function textSignalMatches(agent, terms) {
-    if (terms.length === 0)
-        return [];
-    const searchable = tokenize([agent.name, agent.description, ...agent.capabilities, ...agent.skills, ...agent.workflows].join(' '));
-    return terms.filter((term) => searchable.includes(term));
-}
-function matchingValues(values, requested) {
-    const normalizedValues = new Map(values.map((value) => [normalizeKey(value), value]));
-    const matches = [];
-    for (const requestedValue of requested) {
-        const match = normalizedValues.get(normalizeKey(requestedValue));
-        if (match !== undefined && !matches.includes(match))
-            matches.push(match);
-    }
-    return matches;
-}
-function compareCandidates(a, b) {
-    return (b.score - a.score || modeRank(a.agent.mode) - modeRank(b.agent.mode) || a.agent.name.localeCompare(b.agent.name) || a.agent.id.localeCompare(b.agent.id));
-}
-function compareSkipped(a, b) {
-    return a.agent.name.localeCompare(b.agent.name) || a.agent.id.localeCompare(b.agent.id);
-}
-function modeRank(mode) {
-    return mode === 'agent' ? 0 : 1;
-}
-function toSkipped(agent, reasons) {
-    return { agent: { id: agent.id, name: agent.name, mode: agent.mode, project: agent.project, scope: agent.scope }, reasons };
-}
-function normalizeList(values) {
-    return values.map(normalizeText).filter((value) => value !== undefined);
-}
-function normalizeText(value) {
-    const normalized = value?.trim();
-    return normalized ? normalized : undefined;
-}
-function normalizeKey(value) {
-    return value.trim().toLowerCase();
-}
-function isSddWorkflow(workflow) {
-    return workflow?.trim().toLowerCase() === 'sdd';
-}
-function tokenize(value) {
-    const seen = new Set();
-    return value
-        .toLowerCase()
-        .split(/[^a-z0-9-]+/)
-        .filter(Boolean)
-        .filter((term) => {
-        if (term.length < 3 || seen.has(term))
-            return false;
-        seen.add(term);
-        return true;
-    });
-}
-function ok(value) {
-    return { ok: true, value };
-}
+export * from '../application/agents/agent-resolver.js';