mindforge-cc 11.8.2 → 11.9.0

package/.mindforge/dynamic-workflows/scripts/api-migration.js

@@ -10,147 +10,145 @@ export const meta = {
   ],
 };
 
-export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
-  const CHANGES_SCHEMA = {
-    type: 'object',
-    properties: {
-      apiName: { type: 'string' },
-      oldVersion: { type: 'string' },
-      newVersion: { type: 'string' },
-      breakingChanges: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            endpoint: { type: 'string' },
-            changeType: { type: 'string', enum: ['removed-endpoint', 'renamed-field', 'changed-type', 'removed-field', 'changed-auth', 'changed-status-code', 'changed-behavior'] },
-            description: { type: 'string' },
-            impactedClients: { type: 'string' },
-          },
-          required: ['endpoint', 'changeType', 'description'],
+const CHANGES_SCHEMA = {
+  type: 'object',
+  properties: {
+    apiName: { type: 'string' },
+    oldVersion: { type: 'string' },
+    newVersion: { type: 'string' },
+    breakingChanges: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          endpoint: { type: 'string' },
+          changeType: { type: 'string', enum: ['removed-endpoint', 'renamed-field', 'changed-type', 'removed-field', 'changed-auth', 'changed-status-code', 'changed-behavior'] },
+          description: { type: 'string' },
+          impactedClients: { type: 'string' },
         },
+        required: ['endpoint', 'changeType', 'description'],
       },
-      nonBreakingChanges: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            endpoint: { type: 'string' },
-            changeType: { type: 'string', enum: ['added-endpoint', 'added-optional-field', 'added-header', 'performance-improvement', 'deprecation-notice'] },
-            description: { type: 'string' },
-          },
-          required: ['endpoint', 'changeType', 'description'],
+    },
+    nonBreakingChanges: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          endpoint: { type: 'string' },
+          changeType: { type: 'string', enum: ['added-endpoint', 'added-optional-field', 'added-header', 'performance-improvement', 'deprecation-notice'] },
+          description: { type: 'string' },
         },
+        required: ['endpoint', 'changeType', 'description'],
       },
     },
-    required: ['apiName', 'breakingChanges', 'nonBreakingChanges'],
-  };
+  },
+  required: ['apiName', 'breakingChanges', 'nonBreakingChanges'],
+};
 
-  const VERSIONING_SCHEMA = {
-    type: 'object',
-    properties: {
-      strategy: { type: 'string', enum: ['url-versioning', 'header-versioning', 'semver-package', 'content-negotiation'] },
-      rationale: { type: 'string' },
-      versionIdentifier: { type: 'string' },
-      deprecationPolicy: { type: 'string' },
-      sunsetTimeline: { type: 'string' },
-    },
-    required: ['strategy', 'rationale', 'versionIdentifier', 'deprecationPolicy'],
-  };
+const VERSIONING_SCHEMA = {
+  type: 'object',
+  properties: {
+    strategy: { type: 'string', enum: ['url-versioning', 'header-versioning', 'semver-package', 'content-negotiation'] },
+    rationale: { type: 'string' },
+    versionIdentifier: { type: 'string' },
+    deprecationPolicy: { type: 'string' },
+    sunsetTimeline: { type: 'string' },
+  },
+  required: ['strategy', 'rationale', 'versionIdentifier', 'deprecationPolicy'],
+};
 
-  const GUIDE_SCHEMA = {
-    type: 'object',
-    properties: {
-      summary: { type: 'string' },
-      migrationSteps: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            step: { type: 'number' },
-            title: { type: 'string' },
-            description: { type: 'string' },
-            codeExample: { type: 'string' },
-            requiredBy: { type: 'string' },
-          },
-          required: ['step', 'title', 'description'],
+const GUIDE_SCHEMA = {
+  type: 'object',
+  properties: {
+    summary: { type: 'string' },
+    migrationSteps: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          step: { type: 'number' },
+          title: { type: 'string' },
+          description: { type: 'string' },
+          codeExample: { type: 'string' },
+          requiredBy: { type: 'string' },
         },
+        required: ['step', 'title', 'description'],
       },
-      searchAndReplace: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            find: { type: 'string' },
-            replaceWith: { type: 'string' },
-            context: { type: 'string' },
-          },
-          required: ['find', 'replaceWith'],
+    },
+    searchAndReplace: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          find: { type: 'string' },
+          replaceWith: { type: 'string' },
+          context: { type: 'string' },
         },
+        required: ['find', 'replaceWith'],
       },
     },
-    required: ['summary', 'migrationSteps'],
-  };
+  },
+  required: ['summary', 'migrationSteps'],
+};
 
-  const MATRIX_SCHEMA = {
-    type: 'object',
-    properties: {
-      matrix: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            clientVersion: { type: 'string' },
-            apiV1Compatible: { type: 'boolean' },
-            apiV2Compatible: { type: 'boolean' },
-            migrationRequired: { type: 'boolean' },
-            notes: { type: 'string' },
-          },
-          required: ['clientVersion', 'apiV1Compatible', 'apiV2Compatible', 'migrationRequired'],
+const MATRIX_SCHEMA = {
+  type: 'object',
+  properties: {
+    matrix: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          clientVersion: { type: 'string' },
+          apiV1Compatible: { type: 'boolean' },
+          apiV2Compatible: { type: 'boolean' },
+          migrationRequired: { type: 'boolean' },
+          notes: { type: 'string' },
         },
+        required: ['clientVersion', 'apiV1Compatible', 'apiV2Compatible', 'migrationRequired'],
       },
-      supportEndsDate: { type: 'string' },
-      recommendation: { type: 'string' },
     },
-    required: ['matrix', 'recommendation'],
-  };
+    supportEndsDate: { type: 'string' },
+    recommendation: { type: 'string' },
+  },
+  required: ['matrix', 'recommendation'],
+};
 
-  const target = args || 'current API (provide old/new version paths or describe the changes in args)';
+const target = args || 'current API (provide old/new version paths or describe the changes in args)';
 
-  phase('Detect');
-  log(`Detecting API changes in: ${target}`);
-  const changes = await agent(
-    `Analyze the API changes in: "${target}". Compare old vs new API versions. Classify each change as: BREAKING (removed endpoints, renamed/removed fields, changed types, auth changes, status code changes) or NON-BREAKING (added endpoints, added optional fields, performance improvements, deprecation notices). Include the old and new version identifiers.`,
-    { schema: CHANGES_SCHEMA, label: 'detect-changes' }
-  );
-  if (!changes) { log('Warning: agent returned null for changes, skipping'); return { target, error: 'agent-null' }; }
-  log(`API: ${changes.apiName} — ${changes.breakingChanges.length} breaking, ${changes.nonBreakingChanges.length} non-breaking changes`);
+phase('Detect');
+log(`Detecting API changes in: ${target}`);
+const changes = await agent(
+  `Analyze the API changes in: "${target}". Compare old vs new API versions. Classify each change as: BREAKING (removed endpoints, renamed/removed fields, changed types, auth changes, status code changes) or NON-BREAKING (added endpoints, added optional fields, performance improvements, deprecation notices). Include the old and new version identifiers.`,
+  { schema: CHANGES_SCHEMA, label: 'detect-changes' }
+);
+if (!changes) { log('Warning: agent returned null for changes, skipping'); return { target, error: 'agent-null' }; }
+log(`API: ${changes.apiName} — ${changes.breakingChanges.length} breaking, ${changes.nonBreakingChanges.length} non-breaking changes`);
 
-  phase('Version');
-  const breakingSummary = changes.breakingChanges.map(c => `${c.endpoint}: ${c.changeType} — ${c.description}`).join('\n');
-  const versioning = await agent(
-    `Propose a versioning strategy for: "${changes.apiName}" migrating from ${changes.oldVersion || 'v1'} to ${changes.newVersion || 'v2'}.\n\nBreaking changes:\n${breakingSummary}\n\nRecommend: URL versioning (/v1, /v2), header versioning (API-Version: 2), or semver package versioning. Include: rationale, deprecation policy, and sunset timeline for the old version.`,
-    { schema: VERSIONING_SCHEMA, label: 'versioning' }
-  );
-  if (!versioning) { log('Warning: agent returned null for versioning, skipping'); return { target, changes, error: 'agent-null' }; }
-  log(`Strategy: ${versioning.strategy} — sunset: ${versioning.sunsetTimeline}`);
+phase('Version');
+const breakingSummary = changes.breakingChanges.map(c => `${c.endpoint}: ${c.changeType} — ${c.description}`).join('\n');
+const versioning = await agent(
+  `Propose a versioning strategy for: "${changes.apiName}" migrating from ${changes.oldVersion || 'v1'} to ${changes.newVersion || 'v2'}.\n\nBreaking changes:\n${breakingSummary}\n\nRecommend: URL versioning (/v1, /v2), header versioning (API-Version: 2), or semver package versioning. Include: rationale, deprecation policy, and sunset timeline for the old version.`,
+  { schema: VERSIONING_SCHEMA, label: 'versioning' }
+);
+if (!versioning) { log('Warning: agent returned null for versioning, skipping'); return { target, changes, error: 'agent-null' }; }
+log(`Strategy: ${versioning.strategy} — sunset: ${versioning.sunsetTimeline}`);
 
-  phase('Guide');
-  const guide = await agent(
-    `Write a migration guide for consumers of: "${changes.apiName}" upgrading from ${changes.oldVersion || 'v1'} to ${changes.newVersion || 'v2'}.\n\nBreaking changes:\n${breakingSummary}\n\nVersioning: ${versioning.strategy} (${versioning.versionIdentifier})\n\nProvide: (1) executive summary of what changed and why, (2) numbered migration steps in order, each with description and code example, (3) search-and-replace patterns for automated migration (what to find and replace in client code).`,
-    { schema: GUIDE_SCHEMA, label: 'guide' }
-  );
-  if (!guide) { log('Warning: agent returned null for guide, skipping'); return { target, changes, versioning, error: 'agent-null' }; }
-  log(`Migration guide: ${guide.migrationSteps.length} steps`);
+phase('Guide');
+const guide = await agent(
+  `Write a migration guide for consumers of: "${changes.apiName}" upgrading from ${changes.oldVersion || 'v1'} to ${changes.newVersion || 'v2'}.\n\nBreaking changes:\n${breakingSummary}\n\nVersioning: ${versioning.strategy} (${versioning.versionIdentifier})\n\nProvide: (1) executive summary of what changed and why, (2) numbered migration steps in order, each with description and code example, (3) search-and-replace patterns for automated migration (what to find and replace in client code).`,
+  { schema: GUIDE_SCHEMA, label: 'guide' }
+);
+if (!guide) { log('Warning: agent returned null for guide, skipping'); return { target, changes, versioning, error: 'agent-null' }; }
+log(`Migration guide: ${guide.migrationSteps.length} steps`);
 
-  phase('Matrix');
-  const allChanges = [...changes.breakingChanges, ...changes.nonBreakingChanges];
-  const changeSummary = allChanges.slice(0, 10).map(c => `${c.endpoint}: ${c.changeType}`).join(', ');
-  const matrix = await agent(
-    `Create a compatibility matrix for: "${changes.apiName}"\n\nChanges: ${changeSummary}\n\nVersioning: ${versioning.strategy}\nDeprecation policy: ${versioning.deprecationPolicy}\n\nFor typical client version groups (very-old, old, current, new), show compatibility with each API version and whether migration is required. Include support end date and overall recommendation.`,
-    { schema: MATRIX_SCHEMA, label: 'matrix' }
-  );
-  if (!matrix) { return { target, changes, versioning, guide, error: 'matrix-agent-null' }; }
+phase('Matrix');
+const allChanges = [...changes.breakingChanges, ...changes.nonBreakingChanges];
+const changeSummary = allChanges.slice(0, 10).map(c => `${c.endpoint}: ${c.changeType}`).join(', ');
+const matrix = await agent(
+  `Create a compatibility matrix for: "${changes.apiName}"\n\nChanges: ${changeSummary}\n\nVersioning: ${versioning.strategy}\nDeprecation policy: ${versioning.deprecationPolicy}\n\nFor typical client version groups (very-old, old, current, new), show compatibility with each API version and whether migration is required. Include support end date and overall recommendation.`,
+  { schema: MATRIX_SCHEMA, label: 'matrix' }
+);
+if (!matrix) { return { target, changes, versioning, guide, error: 'matrix-agent-null' }; }
 
-  return { target, changes, versioning, guide, matrix };
-}
+return { target, changes, versioning, guide, matrix };

package/.mindforge/dynamic-workflows/scripts/architecture-modernization.js

@@ -11,101 +11,99 @@ export const meta = {
   ],
 };
 
-export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
-  const MAP_SCHEMA = {
-    type: 'object',
-    properties: {
-      components: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, responsibility: { type: 'string' }, coupling: { type: 'string', enum: ['tight', 'loose', 'very-tight'] }, painPoints: { type: 'array', items: { type: 'string' } } }, required: ['name', 'responsibility', 'coupling'] } },
-      primaryPainPoints: { type: 'array', items: { type: 'string' } },
-      technicalDebt: { type: 'array', items: { type: 'string' } },
-    },
-    required: ['components', 'primaryPainPoints', 'technicalDebt'],
-  };
+const MAP_SCHEMA = {
+  type: 'object',
+  properties: {
+    components: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, responsibility: { type: 'string' }, coupling: { type: 'string', enum: ['tight', 'loose', 'very-tight'] }, painPoints: { type: 'array', items: { type: 'string' } } }, required: ['name', 'responsibility', 'coupling'] } },
+    primaryPainPoints: { type: 'array', items: { type: 'string' } },
+    technicalDebt: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['components', 'primaryPainPoints', 'technicalDebt'],
+};
 
-  const DESIGN_SCHEMA = {
-    type: 'object',
-    properties: {
-      name: { type: 'string' },
-      approach: { type: 'string' },
-      components: { type: 'array', items: { type: 'string' } },
-      pros: { type: 'array', items: { type: 'string' } },
-      cons: { type: 'array', items: { type: 'string' } },
-      migrationComplexity: { type: 'string', enum: ['low', 'medium', 'high', 'very-high'] },
-      timeEstimate: { type: 'string' },
-    },
-    required: ['name', 'approach', 'pros', 'cons', 'migrationComplexity'],
-  };
+const DESIGN_SCHEMA = {
+  type: 'object',
+  properties: {
+    name: { type: 'string' },
+    approach: { type: 'string' },
+    components: { type: 'array', items: { type: 'string' } },
+    pros: { type: 'array', items: { type: 'string' } },
+    cons: { type: 'array', items: { type: 'string' } },
+    migrationComplexity: { type: 'string', enum: ['low', 'medium', 'high', 'very-high'] },
+    timeEstimate: { type: 'string' },
+  },
+  required: ['name', 'approach', 'pros', 'cons', 'migrationComplexity'],
+};
 
-  const VERDICT_SCHEMA = {
-    type: 'object',
-    properties: {
-      winner: { type: 'string' },
-      rationale: { type: 'string' },
-      hybridAdjustments: { type: 'array', items: { type: 'string' } },
-      targetArchDescription: { type: 'string' },
-    },
-    required: ['winner', 'rationale', 'targetArchDescription'],
-  };
+const VERDICT_SCHEMA = {
+  type: 'object',
+  properties: {
+    winner: { type: 'string' },
+    rationale: { type: 'string' },
+    hybridAdjustments: { type: 'array', items: { type: 'string' } },
+    targetArchDescription: { type: 'string' },
+  },
+  required: ['winner', 'rationale', 'targetArchDescription'],
+};
 
-  const ROADMAP_SCHEMA = {
-    type: 'object',
-    properties: {
-      phases: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            phaseNum: { type: 'number' },
-            name: { type: 'string' },
-            work: { type: 'array', items: { type: 'string' } },
-            riskGates: { type: 'array', items: { type: 'string' } },
-            rollbackCheckpoint: { type: 'string' },
-            durationWeeks: { type: 'number' },
-          },
-          required: ['phaseNum', 'name', 'work', 'riskGates', 'rollbackCheckpoint'],
+const ROADMAP_SCHEMA = {
+  type: 'object',
+  properties: {
+    phases: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          phaseNum: { type: 'number' },
+          name: { type: 'string' },
+          work: { type: 'array', items: { type: 'string' } },
+          riskGates: { type: 'array', items: { type: 'string' } },
+          rollbackCheckpoint: { type: 'string' },
+          durationWeeks: { type: 'number' },
         },
+        required: ['phaseNum', 'name', 'work', 'riskGates', 'rollbackCheckpoint'],
       },
-      totalDurationWeeks: { type: 'number' },
-      criticalDependencies: { type: 'array', items: { type: 'string' } },
     },
-    required: ['phases', 'totalDurationWeeks'],
-  };
+    totalDurationWeeks: { type: 'number' },
+    criticalDependencies: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['phases', 'totalDurationWeeks'],
+};
 
-  const target = args || 'current codebase (describe your modernization goal in args)';
+const target = args || 'current codebase (describe your modernization goal in args)';
 
-  phase('Map');
-  log(`Mapping current architecture for: ${target}`);
-  const archMap = await agent(
-    `Map the current architecture of: "${target}". Identify all major components, their responsibilities, coupling levels (tight/loose), and pain points. List the primary architectural pain points and technical debt items that motivate modernization.`,
-    { schema: MAP_SCHEMA, label: 'arch-map' }
-  );
-  if (!archMap) { log('Warning: agent returned null for archMap, skipping'); return { target, error: 'agent-null' }; }
-  log(`Found ${archMap.components.length} components, ${archMap.primaryPainPoints.length} pain points`);
+phase('Map');
+log(`Mapping current architecture for: ${target}`);
+const archMap = await agent(
+  `Map the current architecture of: "${target}". Identify all major components, their responsibilities, coupling levels (tight/loose), and pain points. List the primary architectural pain points and technical debt items that motivate modernization.`,
+  { schema: MAP_SCHEMA, label: 'arch-map' }
+);
+if (!archMap) { log('Warning: agent returned null for archMap, skipping'); return { target, error: 'agent-null' }; }
+log(`Found ${archMap.components.length} components, ${archMap.primaryPainPoints.length} pain points`);
 
-  phase('Design');
-  const mapContext = `Current architecture: ${archMap.components.map(c => `${c.name}(${c.coupling} coupling)`).join(', ')}\nPain points: ${archMap.primaryPainPoints.join(', ')}`;
-  const designs = await parallel([
-    () => agent(`Design a CONSERVATIVE modernization architecture for: "${target}". ${mapContext}. Propose incremental improvements with minimal disruption — strangler fig pattern, adapter layers, gradual extraction. Optimize for low migration risk.`, { schema: DESIGN_SCHEMA, label: 'design-conservative', phase: 'Design' }),
-    () => agent(`Design an AGGRESSIVE modernization architecture for: "${target}". ${mapContext}. Propose a modern target state — microservices, event-driven, serverless, or modern monolith. Optimize for long-term maintainability.`, { schema: DESIGN_SCHEMA, label: 'design-aggressive', phase: 'Design' }),
-    () => agent(`Design a PRAGMATIC modernization architecture for: "${target}". ${mapContext}. Balance risk vs benefit — modular monolith, domain-driven boundaries, selective extraction of high-value services. Optimize for team productivity.`, { schema: DESIGN_SCHEMA, label: 'design-pragmatic', phase: 'Design' }),
-  ]);
+phase('Design');
+const mapContext = `Current architecture: ${archMap.components.map(c => `${c.name}(${c.coupling} coupling)`).join(', ')}\nPain points: ${archMap.primaryPainPoints.join(', ')}`;
+const designs = await parallel([
+  () => agent(`Design a CONSERVATIVE modernization architecture for: "${target}". ${mapContext}. Propose incremental improvements with minimal disruption — strangler fig pattern, adapter layers, gradual extraction. Optimize for low migration risk.`, { schema: DESIGN_SCHEMA, label: 'design-conservative', phase: 'Design' }),
+  () => agent(`Design an AGGRESSIVE modernization architecture for: "${target}". ${mapContext}. Propose a modern target state — microservices, event-driven, serverless, or modern monolith. Optimize for long-term maintainability.`, { schema: DESIGN_SCHEMA, label: 'design-aggressive', phase: 'Design' }),
+  () => agent(`Design a PRAGMATIC modernization architecture for: "${target}". ${mapContext}. Balance risk vs benefit — modular monolith, domain-driven boundaries, selective extraction of high-value services. Optimize for team productivity.`, { schema: DESIGN_SCHEMA, label: 'design-pragmatic', phase: 'Design' }),
+]);
 
-  phase('Select');
-  const designsText = designs.filter(Boolean).map(d => `Option: ${d.name}\nApproach: ${d.approach}\nPros: ${d.pros.join(', ')}\nCons: ${d.cons.join(', ')}\nComplexity: ${d.migrationComplexity}\nTime: ${d.timeEstimate}`).join('\n\n');
-  const verdict = await agent(
-    `Select the best modernization architecture for: "${target}"\n\nThree options:\n${designsText}\n\nChoose the winner based on: migration risk, team capability, business continuity, long-term value. Suggest hybrid adjustments that take the best elements from runners-up. Describe the final target architecture.`,
-    { schema: VERDICT_SCHEMA, label: 'design-select' }
-  );
-  if (!verdict) { log('Warning: agent returned null for verdict, skipping'); return { target, archMap, designs: designs.filter(Boolean), error: 'agent-null' }; }
-  log(`Selected: ${verdict.winner} — ${verdict.rationale.slice(0, 80)}`);
+phase('Select');
+const designsText = designs.filter(Boolean).map(d => `Option: ${d.name}\nApproach: ${d.approach}\nPros: ${d.pros.join(', ')}\nCons: ${d.cons.join(', ')}\nComplexity: ${d.migrationComplexity}\nTime: ${d.timeEstimate}`).join('\n\n');
+const verdict = await agent(
+  `Select the best modernization architecture for: "${target}"\n\nThree options:\n${designsText}\n\nChoose the winner based on: migration risk, team capability, business continuity, long-term value. Suggest hybrid adjustments that take the best elements from runners-up. Describe the final target architecture.`,
+  { schema: VERDICT_SCHEMA, label: 'design-select' }
+);
+if (!verdict) { log('Warning: agent returned null for verdict, skipping'); return { target, archMap, designs: designs.filter(Boolean), error: 'agent-null' }; }
+log(`Selected: ${verdict.winner} — ${verdict.rationale.slice(0, 80)}`);
 
-  phase('Roadmap');
-  phase('Sequence');
-  const roadmap = await agent(
-    `Create a phased migration roadmap for: "${target}"\n\nTarget architecture: ${verdict.targetArchDescription}\n\nCurrent pain points: ${archMap.primaryPainPoints.join(', ')}\n\nSequence the work into migration phases with: specific work items, risk gates (conditions that must be true before proceeding), rollback checkpoints, and duration estimates. Ensure each phase is independently deployable.`,
-    { schema: ROADMAP_SCHEMA, label: 'sequence' }
-  );
-  if (!roadmap) { return { target, archMap, designs: designs.filter(Boolean), verdict, error: 'roadmap-agent-null' }; }
+phase('Roadmap');
+phase('Sequence');
+const roadmap = await agent(
+  `Create a phased migration roadmap for: "${target}"\n\nTarget architecture: ${verdict.targetArchDescription}\n\nCurrent pain points: ${archMap.primaryPainPoints.join(', ')}\n\nSequence the work into migration phases with: specific work items, risk gates (conditions that must be true before proceeding), rollback checkpoints, and duration estimates. Ensure each phase is independently deployable.`,
+  { schema: ROADMAP_SCHEMA, label: 'sequence' }
+);
+if (!roadmap) { return { target, archMap, designs: designs.filter(Boolean), verdict, error: 'roadmap-agent-null' }; }
 
-  return { target, archMap, designs: designs.filter(Boolean), verdict, roadmap };
-}
+return { target, archMap, designs: designs.filter(Boolean), verdict, roadmap };