@llm-dev-ops/agentics-cli 2.7.36 → 2.7.38

package/dist/synthesis/agent-fleet-decomposer.js

@@ -1,696 +0,0 @@
-/**
- * ADR-PIPELINE-099 D1.3 — Agent-fleet decomposition strategy for Phase 5a.
- *
- * Walks `<runDir>/agent-responses.json` to extract structured outputs from
- * the copilot fleet (decomposer.sub_objectives, planner.steps,
- * clarifier.assumptions/clarifications) and combines them with scenario
- * domain entities, success criteria, and risk register entries to produce
- * a `BuildableUnit[]` shape — one unit per decomposer sub-objective (or
- * planner step, when the decomposer is silent).
- *
- * Each unit carries:
- *   - the source agent + index that produced it (for trace)
- *   - acceptance criteria (the Definition of Done for that prompt)
- *   - dependencies (named by id of other units)
- *   - complexity score (used by the prompt template to set scope)
- *   - load-bearing assumptions surfaced from the clarifier
- *   - guardrails surfaced from scenario.constraints + risk_register
- *
- * The downstream `phase5aGenerateFromAgentFleet` strategy converts each
- * unit into one `prompts/impl-NNN-<slug>.md` file. The contract is:
- * ≥6 units when the decomposer produced ≥6 sub_objectives; otherwise
- * tier-3 returns whatever it has and the caller back-fills with tier-4.
- *
- * No external deps — pure file IO + JSON parsing.
- */
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-/**
- * Decompose Phase-1 fleet output into buildable units. Returns an empty
- * units array (with whatever context is available) when no agent
- * decomposition is recoverable — the caller decides whether to fall through
- * to the success-criterion fallback.
- */
-export function decomposeAgentFleet(runDir, scenarioQuery) {
-    const agentRows = readAgentResponses(runDir);
-    const decomposer = pickAgent(agentRows, 'copilot', 'decomposer');
-    const planner = pickAgent(agentRows, 'copilot', 'planner');
-    const clarifier = pickAgent(agentRows, 'copilot', 'clarifier');
-    const scenario = readScenario(runDir);
-    const riskAssessment = readRiskAssessment(runDir);
-    // ── Build context ────────────────────────────────────────────────────────
-    const assumptions = extractStringArray(clarifier, ['assumptions']) ?? [];
-    const clarifications = extractStringArray(clarifier, ['clarifications']) ?? [];
-    const successCriteria = extractStringArray(scenario, ['success_criteria', 'successCriteria']) ?? [];
-    const constraints = extractStringArray(scenario, ['constraints']) ?? [];
-    const domainEntities = extractStringArray(scenario, ['domain_entities', 'domainEntities']) ?? [];
-    const systems = extractStringArray(scenario, ['systems']) ?? [];
-    const risks = extractRiskRegister(riskAssessment);
-    const context = {
-        assumptions: assumptions.slice(0, 8),
-        clarifications: clarifications.slice(0, 6),
-        successCriteria,
-        constraints,
-        domainEntities,
-        systems,
-        risks: risks.slice(0, 6),
-        scenarioQuery,
-    };
-    const subObjectives = extractObjectArray(decomposer, ['sub_objectives', 'subObjectives']) ?? [];
-    const plannerSteps = extractObjectArray(planner, ['steps']) ?? [];
-    const units = [];
-    // Tier-3 happy path: decomposer produced sub-objectives. Use them.
-    if (subObjectives.length > 0) {
-        subObjectives.forEach((so, idx) => {
-            const title = String(so.title ?? `Build unit ${idx + 1}`).trim();
-            const slug = slugify(title) || `unit-${idx + 1}`;
-            const id = `unit-${pad3(idx + 1)}-${slug}`;
-            const complexity = parseComplexity(so.complexity);
-            const acceptance = (Array.isArray(so.acceptance_criteria)
-                ? so.acceptance_criteria.map(String).filter(Boolean)
-                : []);
-            const deps = resolveDeps(so.dependencies, units);
-            units.push({
-                id,
-                slug,
-                title,
-                description: String(so.description ?? title),
-                complexity,
-                acceptanceCriteria: acceptance,
-                dependencies: deps,
-                tier: classifyTier(title, so.description ?? ''),
-                sourceAgent: 'copilot/decomposer',
-                sourceIndex: idx,
-            });
-        });
-    }
-    // Supplement with planner steps that have no decomposer counterpart.
-    if (plannerSteps.length > 0 && units.length < plannerSteps.length) {
-        plannerSteps.forEach((step, idx) => {
-            const title = String(step.name ?? step.title ?? `Plan step ${idx + 1}`).trim();
-            // De-duplicate against existing units by slug.
-            const slug = slugify(title) || `step-${idx + 1}`;
-            if (units.some(u => u.slug === slug))
-                return;
-            const id = `unit-${pad3(units.length + 1)}-${slug}`;
-            const acceptance = Array.isArray(step.criteria)
-                ? step.criteria.map(String).filter(Boolean)
-                : (typeof step.criteria === 'string' && step.criteria.trim() ? [step.criteria] : []);
-            const deps = resolveDeps(step.dependencies, units);
-            units.push({
-                id,
-                slug,
-                title,
-                description: String(step.description ?? title),
-                complexity: parseComplexity(step.effort),
-                acceptanceCriteria: acceptance,
-                dependencies: deps,
-                tier: classifyTier(title, step.description ?? ''),
-                sourceAgent: 'copilot/planner',
-                sourceIndex: idx,
-            });
-        });
-    }
-    // Final ordering: foundation → integration → domain → presentation → validation
-    const tierOrder = {
-        foundation: 0,
-        integration: 1,
-        domain: 2,
-        presentation: 3,
-        validation: 4,
-    };
-    units.sort((a, b) => tierOrder[a.tier] - tierOrder[b.tier]);
-    // Re-id after sort so order matches numeric prefix.
-    const ordered = units.map((u, idx) => ({
-        ...u,
-        id: `unit-${pad3(idx + 1)}-${u.slug}`,
-    }));
-    return {
-        units: ordered,
-        context,
-        provenance: {
-            decomposerCount: subObjectives.length,
-            plannerCount: plannerSteps.length,
-            clarifierAssumptionsCount: assumptions.length,
-            riskRegisterCount: risks.length,
-        },
-    };
-}
-export function renderUnitPromptMarkdown(unit, unitOrder, totalUnits, context, 
-/** ADRs that match this unit by keyword overlap. May be empty. */
-governingAdrs, 
-/** DDD bounded contexts that match this unit by keyword overlap. May be empty. */
-governingContexts) {
-    const lines = [];
-    // Frontmatter — declares provenance + dependencies.
-    lines.push('---');
-    lines.push(`id: ${unit.id}`);
-    lines.push(`title: ${escapeYamlString(unit.title)}`);
-    lines.push(`order: ${unitOrder}`);
-    lines.push(`tier: ${unit.tier}`);
-    lines.push(`complexity: ${unit.complexity}`);
-    lines.push(`generator: agent-fleet`);
-    lines.push(`source_agent: ${unit.sourceAgent}`);
-    lines.push(`source_index: ${unit.sourceIndex}`);
-    lines.push(`degraded_mode: false`);
-    lines.push(`quality: directional`);
-    if (unit.dependencies.length === 0) {
-        lines.push(`dependency_root: true`);
-    }
-    else {
-        lines.push(`dependencies:`);
-        for (const d of unit.dependencies)
-            lines.push(`  - ${d}`);
-    }
-    if (governingAdrs.length > 0) {
-        lines.push(`adrs:`);
-        for (const a of governingAdrs)
-            lines.push(`  - ${a.id}`);
-    }
-    if (governingContexts.length > 0) {
-        lines.push(`bounded_contexts:`);
-        for (const c of governingContexts)
-            lines.push(`  - ${c.name}`);
-    }
-    lines.push('---');
-    lines.push('');
-    lines.push(`# Build Step ${unitOrder} of ${totalUnits}: ${unit.title}`);
-    lines.push('');
-    lines.push(`**Tier:** ${unit.tier} · **Complexity:** ${unit.complexity}/5 · **Source:** \`${unit.sourceAgent}\` (output index ${unit.sourceIndex})`);
-    lines.push('');
-    // Project context — every prompt must be self-contained.
-    if (context.scenarioQuery) {
-        lines.push('## Project Brief');
-        lines.push('');
-        lines.push(context.scenarioQuery);
-        lines.push('');
-    }
-    // Step description.
-    lines.push('## What This Step Builds');
-    lines.push('');
-    lines.push(unit.description);
-    lines.push('');
-    // Dependencies — name what's already been built.
-    if (unit.dependencies.length > 0) {
-        lines.push('## Depends On (already built)');
-        lines.push('');
-        for (const d of unit.dependencies)
-            lines.push(`- \`${d}\` — import its public API`);
-        lines.push('');
-    }
-    else {
-        lines.push('## Depends On');
-        lines.push('');
-        lines.push('_Foundation step — no prior dependencies. Build the core types and interfaces that later steps will import._');
-        lines.push('');
-    }
-    // Governing ADRs — required for ADR-099 D1: every prompt cites its ADR.
-    if (governingAdrs.length > 0) {
-        lines.push(`## Governing Architecture Decisions (${governingAdrs.length})`);
-        lines.push('');
-        for (const a of governingAdrs) {
-            lines.push(`### ${a.id}: ${a.title}`);
-            if (a.decision) {
-                lines.push('');
-                lines.push(`**Decision:** ${a.decision.split('\n')[0]}`);
-            }
-            lines.push('');
-        }
-    }
-    // Governing DDD contexts.
-    if (governingContexts.length > 0) {
-        lines.push(`## Governing Domain Contexts (${governingContexts.length})`);
-        lines.push('');
-        for (const c of governingContexts) {
-            lines.push(`### ${c.name}`);
-            if (c.description) {
-                lines.push('');
-                lines.push(c.description);
-            }
-            if (c.aggregates && c.aggregates.length > 0) {
-                lines.push('');
-                lines.push('**Aggregates:**');
-                for (const ag of c.aggregates) {
-                    lines.push(`- **${ag.name}**${ag.root ? ` (root: ${ag.root})` : ''}`);
-                }
-            }
-            if (c.commands && c.commands.length > 0) {
-                lines.push('');
-                lines.push(`**Commands:** ${c.commands.join(', ')}`);
-            }
-            if (c.queries && c.queries.length > 0) {
-                lines.push(`**Queries:** ${c.queries.join(', ')}`);
-            }
-            if (c.domainEvents && c.domainEvents.length > 0) {
-                lines.push(`**Events:** ${c.domainEvents.join(', ')}`);
-            }
-            lines.push('');
-        }
-    }
-    // Definition of Done.
-    if (unit.acceptanceCriteria.length > 0) {
-        lines.push('## Definition of Done (acceptance criteria)');
-        lines.push('');
-        for (const ac of unit.acceptanceCriteria)
-            lines.push(`- ${ac}`);
-        lines.push('');
-    }
-    // Load-bearing assumptions — surface from clarifier so the implementer
-    // doesn't unknowingly violate one.
-    if (context.assumptions.length > 0) {
-        lines.push('## Load-Bearing Assumptions (from copilot/clarifier)');
-        lines.push('');
-        lines.push('> Violating any of these requires a callout in the impl plan, not silent breakage.');
-        lines.push('');
-        for (const a of context.assumptions.slice(0, 6))
-            lines.push(`- ${a}`);
-        lines.push('');
-    }
-    // Guardrails — constraints + top risks.
-    if (context.constraints.length > 0 || context.risks.length > 0) {
-        lines.push('## Guardrails');
-        lines.push('');
-        if (context.constraints.length > 0) {
-            lines.push('**Constraints:**');
-            for (const c of context.constraints.slice(0, 6))
-                lines.push(`- ${c}`);
-            lines.push('');
-        }
-        if (context.risks.length > 0) {
-            lines.push('**Risks to mitigate in this slice:**');
-            for (const r of context.risks.slice(0, 4)) {
-                lines.push(`- ${r.description}${r.severity ? ` _(${r.severity})_` : ''}`);
-            }
-            lines.push('');
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────────
-    // ADR-PIPELINE-102 — copy-paste-ready Implementation Prompt block.
-    // ─────────────────────────────────────────────────────────────────────
-    // The body of every impl-prompt is wrapped in a code fence so a developer
-    // (or coding agent) can paste it into a chat verbatim and start
-    // building. Inside the fence we include: the specific scope, a list of
-    // typed signatures pulled from governing ADR components, invariant
-    // references from DDD aggregates, TDD requirements, and verification
-    // commands.
-    //
-    // Reference shape: docs/good_implementation_prompts_example.md (each
-    // "## Prompt NN" section has its body wrapped in ``` fences with
-    // specific Rust trait signatures, struct fields, and `cargo test`
-    // verification commands).
-    lines.push('## Implementation Prompt');
-    lines.push('');
-    lines.push('Copy the block below into your coding agent verbatim. It is a complete build instruction grounded in the governing ADRs/DDDs.');
-    lines.push('');
-    lines.push('```');
-    lines.push(buildCopyPasteReadyPromptBody(unit, unitOrder, totalUnits, context, governingAdrs, governingContexts));
-    lines.push('```');
-    lines.push('');
-    // Reference list — short, pointer-only.
-    lines.push('## References');
-    lines.push('');
-    if (governingAdrs.length > 0) {
-        lines.push(`- ADRs: ${governingAdrs.map(a => `\`${a.id}\``).join(', ')}`);
-    }
-    if (governingContexts.length > 0) {
-        lines.push(`- Bounded contexts: ${governingContexts.map(c => `\`${c.name}\``).join(', ')}`);
-    }
-    if (unit.dependencies.length > 0) {
-        lines.push(`- Prior units: ${unit.dependencies.map(d => `\`${d}\``).join(', ')}`);
-    }
-    lines.push(`- Source: \`${unit.sourceAgent}\` (output index ${unit.sourceIndex})`);
-    lines.push('');
-    return lines.join('\n');
-}
-/**
- * Build the body that goes inside the copy-paste-ready ``` fence. Mirrors
- * the structure of `docs/good_implementation_prompts_example.md`.
- */
-function buildCopyPasteReadyPromptBody(unit, unitOrder, totalUnits, context, adrs, contexts) {
-    const out = [];
-    out.push(`Implement Build Step ${unitOrder} of ${totalUnits}: ${unit.title}.`);
-    out.push('');
-    out.push(unit.description);
-    out.push('');
-    if (unit.dependencies.length > 0) {
-        out.push(`Depends on (already implemented in prior steps): ${unit.dependencies.join(', ')}.`);
-        out.push('Import their public API instead of redefining types.');
-        out.push('');
-    }
-    // Specific items to implement, sourced from the governing ADRs/DDDs.
-    if (adrs.length > 0 || contexts.length > 0) {
-        out.push('Implement the following types, traits, and modules:');
-        out.push('');
-        let itemIdx = 0;
-        for (const adr of adrs) {
-            if (!adr.components || adr.components.length === 0)
-                continue;
-            for (const comp of adr.components) {
-                itemIdx++;
-                const desc = comp.description ? ` — ${truncate(comp.description, 200)}` : '';
-                out.push(`${itemIdx}. ${comp.name}${desc}`);
-                if (comp.codeExample && comp.codeExample.code.trim()) {
-                    out.push('');
-                    out.push('   ```' + (comp.codeExample.language || ''));
-                    for (const codeLine of comp.codeExample.code.trim().split('\n')) {
-                        out.push(`   ${codeLine}`);
-                    }
-                    out.push('   ```');
-                }
-                if (comp.performanceCharacteristics && comp.performanceCharacteristics.length > 0) {
-                    out.push('');
-                    out.push('   Performance requirements:');
-                    for (const p of comp.performanceCharacteristics) {
-                        out.push(`   - ${p}`);
-                    }
-                }
-                out.push('');
-            }
-        }
-        // DDD aggregates — list invariants the implementation must enforce.
-        for (const ctx of contexts) {
-            if (!ctx.aggregates || ctx.aggregates.length === 0)
-                continue;
-            for (const ag of ctx.aggregates) {
-                itemIdx++;
-                const subjects = [];
-                if (ag.entities && ag.entities.length > 0)
-                    subjects.push(`entities: ${ag.entities.join(', ')}`);
-                if (ag.valueObjects && ag.valueObjects.length > 0)
-                    subjects.push(`value objects: ${ag.valueObjects.join(', ')}`);
-                const subjectStr = subjects.length > 0 ? ` (${subjects.join('; ')})` : '';
-                out.push(`${itemIdx}. ${ag.name} aggregate${ag.root ? ` rooted at ${ag.root}` : ''}${subjectStr}`);
-                if (ag.invariants && ag.invariants.length > 0) {
-                    out.push('');
-                    out.push('   Invariants to enforce:');
-                    for (const inv of ag.invariants) {
-                        out.push(`   - ${inv}`);
-                    }
-                }
-                out.push('');
-            }
-        }
-        if (itemIdx === 0) {
-            // No ADR components / aggregates — fall through to a minimum scope
-            // pulled from acceptance criteria.
-            out.push('Scope this slice to the acceptance criteria below; define the minimum public API, types, and module layout that satisfies them.');
-            out.push('');
-        }
-    }
-    // Acceptance criteria become explicit "must satisfy" bullets.
-    if (unit.acceptanceCriteria.length > 0) {
-        out.push('Acceptance criteria (each must be observable in tests or runtime behavior):');
-        for (const ac of unit.acceptanceCriteria) {
-            out.push(`- ${ac}`);
-        }
-        out.push('');
-    }
-    // Load-bearing assumptions become guardrails the implementer must respect.
-    if (context.assumptions.length > 0) {
-        out.push('Load-bearing assumptions (DO NOT silently violate; if you must, raise the conflict):');
-        for (const a of context.assumptions.slice(0, 4)) {
-            out.push(`- ${a}`);
-        }
-        out.push('');
-    }
-    // System constraints — short and explicit.
-    if (context.constraints.length > 0) {
-        out.push('System constraints to respect:');
-        for (const c of context.constraints.slice(0, 4)) {
-            out.push(`- ${c}`);
-        }
-        out.push('');
-    }
-    // TDD + production-quality bar.
-    out.push('Build expectations:');
-    out.push('- Write tests first (London-school TDD). Mock dependencies from prior units; do not call them transitively in unit tests.');
-    out.push('- Real domain logic — no stubs, no TODO scaffolds, no placeholder bodies.');
-    out.push('- Validate ALL external input with the project\'s validation library (e.g. Zod for TS, serde+validator for Rust, pydantic for Python).');
-    out.push('- Public API surface MUST be exported so the next build step can import it. Document the exports.');
-    out.push('- Structured logging via the project logger — never console.log/print/println in production paths.');
-    out.push('- Zero compilation errors. Zero `any`-typed domain values. Zero `unwrap()` without justification.');
-    out.push('');
-    // Verification — concrete commands for the implementer to run.
-    out.push('Verification before marking this step complete:');
-    out.push('- All new tests pass.');
-    out.push('- The full unit test suite passes.');
-    out.push('- The lint/typecheck pipeline passes.');
-    out.push('- Public API surface compiles in isolation (no leaking internal-only types).');
-    out.push('');
-    // ADR/DDD pointer-only references — keep the prompt body lean.
-    if (adrs.length > 0) {
-        out.push(`Reference: ${adrs.map(a => `${a.id} (${truncate(a.title, 60)})`).join('; ')}`);
-    }
-    if (contexts.length > 0) {
-        out.push(`Domain context(s): ${contexts.map(c => c.name).join(', ')}`);
-    }
-    return out.join('\n');
-}
-// ── Helpers ────────────────────────────────────────────────────────────────
-function readAgentResponses(runDir) {
-    const candidates = [
-        path.join(runDir, 'agent-responses.json'),
-        path.join(runDir, 'phase1', 'agent-responses.json'),
-    ];
-    for (const p of candidates) {
-        try {
-            const raw = fs.readFileSync(p, 'utf-8');
-            const parsed = JSON.parse(raw);
-            if (parsed && Array.isArray(parsed.agents))
-                return parsed.agents;
-        }
-        catch {
-            // try next
-        }
-    }
-    return [];
-}
-function readScenario(runDir) {
-    for (const rel of ['scenario.json', 'phase1/scenario.json']) {
-        try {
-            const p = path.join(runDir, rel);
-            const raw = fs.readFileSync(p, 'utf-8');
-            const parsed = JSON.parse(raw);
-            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-                return parsed;
-            }
-        }
-        catch { /* try next */ }
-    }
-    return undefined;
-}
-function readRiskAssessment(runDir) {
-    for (const rel of ['risk-assessment.json', 'phase1/risk-assessment.json']) {
-        try {
-            const p = path.join(runDir, rel);
-            const raw = fs.readFileSync(p, 'utf-8');
-            const parsed = JSON.parse(raw);
-            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-                return parsed;
-            }
-        }
-        catch { /* try next */ }
-    }
-    return undefined;
-}
-function pickAgent(rows, domain, agent) {
-    const row = rows.find(r => r.domain === domain && r.agent === agent && r.status && r.status >= 200 && r.status < 300);
-    if (!row || !row.response_truncated)
-        return undefined;
-    // Strip truncation marker if present.
-    let raw = row.response_truncated.trim();
-    if (raw.endsWith('... [truncated]')) {
-        raw = raw.slice(0, -'... [truncated]'.length);
-    }
-    // The truncated payload is JSON-encoded; parse defensively.
-    try {
-        const parsed = JSON.parse(raw);
-        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-            return parsed;
-        }
-    }
-    catch {
-        // Common case — truncation cut mid-string. Walk back to the last } and retry.
-        const lastBrace = raw.lastIndexOf('}');
-        if (lastBrace > 0) {
-            try {
-                const parsed = JSON.parse(raw.slice(0, lastBrace + 1));
-                if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-                    return parsed;
-                }
-            }
-            catch { /* give up */ }
-        }
-    }
-    return undefined;
-}
-function extractStringArray(obj, keys) {
-    if (!obj)
-        return undefined;
-    for (const key of keys) {
-        // Direct array of strings.
-        const v = obj[key];
-        if (Array.isArray(v)) {
-            const strings = [];
-            for (const item of v) {
-                if (typeof item === 'string')
-                    strings.push(item);
-                else if (item && typeof item === 'object') {
-                    // Could be {description: ...} or {assumption: ...} etc.
-                    const o = item;
-                    for (const subKey of ['description', 'assumption', 'text', 'criterion', 'constraint', 'name', 'title']) {
-                        if (typeof o[subKey] === 'string') {
-                            strings.push(o[subKey]);
-                            break;
-                        }
-                    }
-                }
-            }
-            if (strings.length > 0)
-                return strings;
-        }
-        // Sometimes nested under outputs.
-        const outputs = obj['outputs'];
-        if (outputs && typeof outputs === 'object' && !Array.isArray(outputs)) {
-            const nested = outputs[key];
-            if (Array.isArray(nested)) {
-                const strings = [];
-                for (const item of nested) {
-                    if (typeof item === 'string')
-                        strings.push(item);
-                    else if (item && typeof item === 'object') {
-                        const o = item;
-                        for (const subKey of ['description', 'assumption', 'text', 'criterion', 'constraint', 'name', 'title']) {
-                            if (typeof o[subKey] === 'string') {
-                                strings.push(o[subKey]);
-                                break;
-                            }
-                        }
-                    }
-                }
-                if (strings.length > 0)
-                    return strings;
-            }
-        }
-    }
-    return undefined;
-}
-function extractObjectArray(obj, keys) {
-    if (!obj)
-        return undefined;
-    for (const key of keys) {
-        const v = obj[key];
-        if (Array.isArray(v))
-            return v;
-        const outputs = obj['outputs'];
-        if (outputs && typeof outputs === 'object' && !Array.isArray(outputs)) {
-            const nested = outputs[key];
-            if (Array.isArray(nested))
-                return nested;
-        }
-    }
-    return undefined;
-}
-function extractRiskRegister(risk) {
-    if (!risk)
-        return [];
-    const candidates = [];
-    for (const key of ['risk_register', 'risks', 'register']) {
-        const v = risk[key];
-        if (Array.isArray(v))
-            candidates.push(...v);
-    }
-    const out = [];
-    for (const item of candidates) {
-        if (typeof item === 'string') {
-            out.push({ description: item });
-        }
-        else if (item && typeof item === 'object') {
-            const o = item;
-            const desc = o['description'] ?? o['risk'] ?? o['name'] ?? o['title'];
-            if (typeof desc === 'string' && desc.trim().length > 0) {
-                const sev = o['severity'] ?? o['impact'] ?? o['priority'];
-                out.push({
-                    description: desc,
-                    severity: typeof sev === 'string' ? sev : undefined,
-                });
-            }
-        }
-    }
-    return out;
-}
-function parseComplexity(v) {
-    if (typeof v === 'number' && Number.isFinite(v)) {
-        return Math.max(1, Math.min(5, Math.round(v)));
-    }
-    if (typeof v === 'string') {
-        const lower = v.toLowerCase().trim();
-        if (lower === 'low' || lower === 'small' || lower === 'simple')
-            return 2;
-        if (lower === 'medium' || lower === 'moderate')
-            return 3;
-        if (lower === 'high' || lower === 'large' || lower === 'complex')
-            return 4;
-        if (lower === 'critical' || lower === 'extreme')
-            return 5;
-        const n = Number.parseInt(lower, 10);
-        if (!Number.isNaN(n))
-            return Math.max(1, Math.min(5, n));
-    }
-    return 3;
-}
-function classifyTier(title, description) {
-    const t = `${title} ${description}`.toLowerCase();
-    if (/(foundation|setup|bootstrap|domain model|persistence|database|schema|infrastructure|core types|baseline)/.test(t)) {
-        return 'foundation';
-    }
-    if (/(integration|webhook|erp|sap|oracle|salesforce|servicenow|api client|adapter|connector|external)/.test(t)) {
-        return 'integration';
-    }
-    if (/(ui|dashboard|frontend|react|vue|svelte|page|component|presentation|report|visualization)/.test(t)) {
-        return 'presentation';
-    }
-    if (/(test|validation|smoke|hypercare|pilot|qa|verify|verification)/.test(t)) {
-        return 'validation';
-    }
-    return 'domain';
-}
-function resolveDeps(raw, existing) {
-    if (!Array.isArray(raw))
-        return [];
-    const out = [];
-    for (const r of raw) {
-        if (typeof r === 'number' && Number.isInteger(r) && r > 0 && r <= existing.length) {
-            out.push(existing[r - 1].id);
-        }
-        else if (typeof r === 'string') {
-            // Try to match an existing unit by slug or id substring.
-            const slug = slugify(r);
-            const match = existing.find(u => u.slug === slug || u.id.endsWith(slug) || u.id === r);
-            if (match)
-                out.push(match.id);
-            else
-                out.push(slug);
-        }
-    }
-    return out;
-}
-function pad3(n) {
-    return String(n).padStart(3, '0');
-}
-function slugify(text) {
-    return text.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '').slice(0, 60);
-}
-function truncate(text, max) {
-    if (!text)
-        return '';
-    return text.length > max ? text.slice(0, max - 1) + '…' : text;
-}
-function escapeYamlString(s) {
-    // Conservative — wrap in quotes if it contains anything that could confuse a YAML parser.
-    if (/[:#&*!|>'"%@`?[\]{},]/.test(s)) {
-        return `"${s.replace(/"/g, '\\"').replace(/\\/g, '\\\\')}"`;
-    }
-    return s;
-}
-//# sourceMappingURL=agent-fleet-decomposer.js.map