agentic-orchestrator 0.1.28 → 0.2.0

package/apps/control-plane/src/cli/spec-preparation.ts

@@ -0,0 +1,114 @@
+import path from 'node:path';
+import { stableHash } from '../core/fs.js';
+import { ERROR_CODES } from '../core/error-codes.js';
+import type { AppError } from '../providers/providers.js';
+import type { PreparedSpecItem } from './types.js';
+import {
+  buildCanonicalSpecPath,
+  canonicalFeatureIdFromMarkdown,
+  canonicalFeatureIdFromPath,
+  canonicalFeatureIdFromSourceText,
+  isCanonicalSpecPath,
+  isLegacyCanonicalSpecPath,
+} from './spec-utils.js';
+
+export interface SpecPreparationInput {
+  repoRoot: string;
+  sourceContent: string;
+  sourcePath?: string | null;
+  sourceLabel?: string | null;
+  explicitFeatureId?: string | null;
+}
+
+export interface PreparedSpecDraft extends PreparedSpecItem {
+  content: string;
+  write_required: boolean;
+}
+
+function createCollisionError(featureId: string): AppError {
+  const error = new Error(ERROR_CODES.FEATURE_SLUG_COLLISION) as AppError;
+  error.code = ERROR_CODES.FEATURE_SLUG_COLLISION;
+  error.details = { feature_id: featureId };
+  return error;
+}
+
+function normalizeSourcePath(repoRoot: string, sourcePath?: string | null): string | null {
+  if (!sourcePath || sourcePath.trim().length === 0) {
+    return null;
+  }
+  return path.isAbsolute(sourcePath) ? sourcePath : path.join(repoRoot, sourcePath);
+}
+
+function relativeSpecPath(repoRoot: string, candidate: string): string {
+  return path.relative(repoRoot, candidate).replaceAll('\\', '/');
+}
+
+export function prepareSpecDraft(input: SpecPreparationInput): PreparedSpecDraft {
+  const normalizedSourcePath = normalizeSourcePath(input.repoRoot, input.sourcePath);
+  const canonical = normalizedSourcePath
+    ? isCanonicalSpecPath(input.repoRoot, normalizedSourcePath)
+    : null;
+  const legacyCanonical =
+    canonical || !normalizedSourcePath
+      ? null
+      : isLegacyCanonicalSpecPath(input.repoRoot, normalizedSourcePath);
+
+  let featureId: string;
+  let targetPath: string;
+
+  if (canonical) {
+    featureId = canonical;
+    targetPath = normalizedSourcePath!;
+  } else if (legacyCanonical) {
+    featureId = legacyCanonical;
+    targetPath = buildCanonicalSpecPath(input.repoRoot, featureId);
+  } else if (input.explicitFeatureId && input.explicitFeatureId.trim().length > 0) {
+    featureId = canonicalFeatureIdFromSourceText(input.explicitFeatureId, 'explicit_feature_id');
+    targetPath = buildCanonicalSpecPath(input.repoRoot, featureId);
+  } else if (normalizedSourcePath) {
+    try {
+      featureId = canonicalFeatureIdFromPath(normalizedSourcePath);
+    } catch (error) {
+      const appError = error instanceof Error ? (error as AppError) : null;
+      if (appError?.code !== ERROR_CODES.INVALID_FEATURE_SLUG) {
+        throw error;
+      }
+      featureId = canonicalFeatureIdFromMarkdown(
+        input.sourceContent,
+        input.sourceLabel ?? path.basename(normalizedSourcePath),
+      );
+    }
+    targetPath = buildCanonicalSpecPath(input.repoRoot, featureId);
+  } else {
+    featureId = canonicalFeatureIdFromMarkdown(input.sourceContent, input.sourceLabel);
+    targetPath = buildCanonicalSpecPath(input.repoRoot, featureId);
+  }
+
+  return {
+    feature_id: featureId,
+    source_path: relativeSpecPath(
+      input.repoRoot,
+      normalizedSourcePath ?? buildCanonicalSpecPath(input.repoRoot, featureId),
+    ),
+    canonical_spec_path: relativeSpecPath(input.repoRoot, targetPath),
+    source_hash: stableHash(input.sourceContent),
+    content: input.sourceContent,
+    write_required: canonical == null,
+  };
+}
+
+export function prepareSpecDrafts(inputs: SpecPreparationInput[]): PreparedSpecDraft[] {
+  const prepared: PreparedSpecDraft[] = [];
+  const featureIds = new Set<string>();
+
+  for (const input of inputs) {
+    const next = prepareSpecDraft(input);
+    if (featureIds.has(next.feature_id)) {
+      throw createCollisionError(next.feature_id);
+    }
+    featureIds.add(next.feature_id);
+    prepared.push(next);
+  }
+
+  return prepared;
+}

package/apps/control-plane/src/cli/spec-utils.ts

@@ -2,25 +2,104 @@ import path from 'node:path';
 import { ERROR_CODES } from '../core/error-codes.js';
 import type { AppError } from '../providers/providers.js';
 
+const FEATURE_ID_PATTERN = /^[a-z0-9_][a-z0-9_-]*$/;
+
+function createInvalidFeatureIdError(
+  input: string,
+  derivedFeatureId: string | null,
+  details: Record<string, unknown>,
+): AppError {
+  const error = new Error(ERROR_CODES.INVALID_FEATURE_SLUG) as AppError;
+  error.code = ERROR_CODES.INVALID_FEATURE_SLUG;
+  error.details = {
+    ...details,
+    input,
+    derived_feature_id: derivedFeatureId,
+  };
+  return error;
+}
+
+function stripSpecSuffix(value: string): string {
+  if (value.endsWith('.spec')) {
+    return value.slice(0, -'.spec'.length);
+  }
+  if (value.endsWith('-spec')) {
+    return value.slice(0, -'-spec'.length);
+  }
+  return value;
+}
+
+export function normalizeFeatureIdCandidate(input: string): string {
+  const normalized = stripSpecSuffix(input.trim().toLowerCase())
+    .replace(/['".]/g, '')
+    .replace(/[^a-z0-9_-]+/g, '_')
+    .replace(/_{2,}/g, '_')
+    .replace(/-{2,}/g, '-')
+    .replace(/^[-_]+|[-_]+$/g, '');
+  return normalized;
+}
+
 export function canonicalFeatureIdFromPath(inputPath: string): string {
   const basename = path.basename(inputPath);
-  let candidate = basename.replace(/\.[^.]+$/, '');
-  if (candidate.endsWith('.spec')) {
-    candidate = candidate.slice(0, -'.spec'.length);
-  } else if (candidate.endsWith('-spec')) {
-    candidate = candidate.slice(0, -'-spec'.length);
-  }
+  const candidate = stripSpecSuffix(basename.replace(/\.[^.]+$/, ''));
 
-  if (!candidate || !/^[a-z0-9_][a-z0-9_-]*$/.test(candidate)) {
-    const error = new Error(ERROR_CODES.INVALID_FEATURE_SLUG) as AppError;
-    error.code = ERROR_CODES.INVALID_FEATURE_SLUG;
-    error.details = { input_path: inputPath, derived_feature_id: candidate };
-    throw error;
+  if (!candidate || !FEATURE_ID_PATTERN.test(candidate)) {
+    throw createInvalidFeatureIdError(inputPath, candidate, { input_path: inputPath });
   }
 
   return candidate;
 }
 
+export function canonicalFeatureIdFromSourceText(input: string, sourceKind: string): string {
+  const candidate = normalizeFeatureIdCandidate(input);
+  if (!candidate || !FEATURE_ID_PATTERN.test(candidate)) {
+    throw createInvalidFeatureIdError(input, candidate, { source_kind: sourceKind });
+  }
+  return candidate;
+}
+
+function extractFrontMatterFeatureId(content: string): string | null {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*(?:\n|$)/);
+  if (!match) {
+    return null;
+  }
+  const featureIdMatch = match[1].match(/^\s*feature_id\s*:\s*["']?([^"'\n#]+)["']?\s*$/m);
+  return featureIdMatch?.[1]?.trim() || null;
+}
+
+function extractHeading(content: string): string | null {
+  const headingMatch = content.match(/^\s*#\s+(.+?)\s*$/m);
+  return headingMatch?.[1]?.trim() || null;
+}
+
+export function canonicalFeatureIdFromMarkdown(
+  content: string,
+  fallbackLabel?: string | null,
+): string {
+  const frontMatterFeatureId = extractFrontMatterFeatureId(content);
+  if (frontMatterFeatureId) {
+    return canonicalFeatureIdFromSourceText(frontMatterFeatureId, 'markdown_frontmatter');
+  }
+
+  const heading = extractHeading(content);
+  if (heading) {
+    return canonicalFeatureIdFromSourceText(heading, 'markdown_heading');
+  }
+
+  if (fallbackLabel && fallbackLabel.trim().length > 0) {
+    return canonicalFeatureIdFromSourceText(fallbackLabel, 'markdown_fallback');
+  }
+
+  throw createInvalidFeatureIdError(content, null, {
+    source_kind: 'markdown',
+    message: 'Draft requires a feature_id frontmatter field or a level-1 heading.',
+  });
+}
+
+export function buildCanonicalSpecPath(repoRoot: string, featureId: string): string {
+  return path.join(repoRoot, '.aop', 'features', featureId, 'spec.md');
+}
+
 export function isCanonicalSpecPath(repoRoot: string, candidate: string): string | null {
   const relative = path.relative(repoRoot, candidate).replaceAll('\\\\', '/');
   const match = relative.match(/^\.aop\/features\/([a-z0-9_][a-z0-9_-]*)\/spec\.md$/);

package/apps/control-plane/src/cli/status-command-handler.ts

@@ -22,6 +22,22 @@ const ACTIVITY_IDLE_THRESHOLD_MS = 300_000;
 interface DashboardFeature {
   feature_id: string;
   status?: string;
+  human_input?: {
+    open_question_id?: string | null;
+    open_question_count?: number;
+    awaiting_since?: string | null;
+    requested_by_role?: string | null;
+    prompt_summary?: string | null;
+    resume_status?: string | null;
+  };
+  intake?: {
+    status?: string | null;
+    bootstrap_manifest_version?: number | null;
+    verified_manifest_version?: number | null;
+    open_ambiguity_count?: number | null;
+    last_verified_at?: string | null;
+    promotion_basis?: string | null;
+  } | null;
   last_heartbeat_at?: string;
   last_run_at?: string;
   activity_state?: ExtendedActivityState;
@@ -41,6 +57,98 @@ interface DashboardFeature {
 
 interface DashboardData {
   features?: DashboardFeature[];
+  execution_requests?: {
+    items?: Array<Record<string, unknown>>;
+  };
+}
+
+function normalizeHumanInput(feature: DashboardFeature): {
+  open_question_id: string | null;
+  open_question_count: number;
+  awaiting_since: string | null;
+  requested_by_role: string | null;
+  prompt_summary: string | null;
+  resume_status: string | null;
+} {
+  return {
+    open_question_id:
+      typeof feature.human_input?.open_question_id === 'string'
+        ? feature.human_input.open_question_id
+        : null,
+    open_question_count:
+      typeof feature.human_input?.open_question_count === 'number'
+        ? feature.human_input.open_question_count
+        : 0,
+    awaiting_since:
+      typeof feature.human_input?.awaiting_since === 'string'
+        ? feature.human_input.awaiting_since
+        : null,
+    requested_by_role:
+      typeof feature.human_input?.requested_by_role === 'string'
+        ? feature.human_input.requested_by_role
+        : null,
+    prompt_summary:
+      typeof feature.human_input?.prompt_summary === 'string'
+        ? feature.human_input.prompt_summary
+        : null,
+    resume_status:
+      typeof feature.human_input?.resume_status === 'string'
+        ? feature.human_input.resume_status
+        : null,
+  };
+}
+
+function normalizeIntake(feature: DashboardFeature): {
+  intake_status: string | null;
+  bootstrap_manifest_version: number | null;
+  verified_manifest_version: number | null;
+  open_ambiguity_count: number;
+  last_verified_at: string | null;
+  promotion_basis: string | null;
+} {
+  return {
+    intake_status: typeof feature.intake?.status === 'string' ? feature.intake.status : null,
+    bootstrap_manifest_version:
+      typeof feature.intake?.bootstrap_manifest_version === 'number'
+        ? feature.intake.bootstrap_manifest_version
+        : null,
+    verified_manifest_version:
+      typeof feature.intake?.verified_manifest_version === 'number'
+        ? feature.intake.verified_manifest_version
+        : null,
+    open_ambiguity_count:
+      typeof feature.intake?.open_ambiguity_count === 'number'
+        ? feature.intake.open_ambiguity_count
+        : 0,
+    last_verified_at:
+      typeof feature.intake?.last_verified_at === 'string' ? feature.intake.last_verified_at : null,
+    promotion_basis:
+      typeof feature.intake?.promotion_basis === 'string' ? feature.intake.promotion_basis : null,
+  };
+}
+
+function projectExecutionRequestState(request: Record<string, unknown>): Record<string, unknown> {
+  const status = typeof request.status === 'string' ? request.status : 'unknown';
+  if (status !== 'pending') {
+    return request;
+  }
+  const progress =
+    request.progress && typeof request.progress === 'object'
+      ? (request.progress as Record<string, unknown>)
+      : null;
+  const detectedAt = typeof progress?.detected_at === 'string' ? progress.detected_at : null;
+  const deferred = Array.isArray(progress?.deferred) ? progress.deferred : [];
+  const pending_state =
+    deferred.length > 0 ? 'pending_deferred' : detectedAt ? 'pending_detected' : 'pending_unseen';
+
+  return {
+    ...request,
+    pending_state,
+    detected: detectedAt !== null,
+    defer_reasons: deferred.map((item) =>
+      item && typeof item === 'object' ? (item as Record<string, unknown>).reason : null,
+    ),
+  };
 }
 
 function computeFeatureActivity(feature: DashboardFeature): ExtendedActivityState {
@@ -96,6 +204,8 @@ export class StatusCommandHandler {
             feature_id: f.feature_id,
             status: f.status ?? 'unknown',
             activity: computeFeatureActivity(f),
+            ...normalizeHumanInput(f),
+            ...normalizeIntake(f),
           })),
         },
       };
@@ -103,15 +213,27 @@ export class StatusCommandHandler {
 
     const dashboardData = result.data as unknown as DashboardData;
     const rawFeatures = dashboardData?.features ?? [];
+    const rawExecutionRequests = Array.isArray(dashboardData?.execution_requests?.items)
+      ? dashboardData?.execution_requests?.items
+      : [];
     return {
       ok: true,
       data: {
         ...result.data,
         features: rawFeatures.map((f) => ({
           ...f,
+          ...normalizeHumanInput(f),
+          ...normalizeIntake(f),
           activity: computeFeatureActivity(f),
           ...(f.pr !== undefined ? { pr_info: f.pr } : {}),
         })),
+        execution_requests:
+          dashboardData?.execution_requests && typeof dashboardData.execution_requests === 'object'
+            ? {
+                ...dashboardData.execution_requests,
+                items: rawExecutionRequests.map((request) => projectExecutionRequestState(request)),
+              }
+            : undefined,
       },
     };
   }

package/apps/control-plane/src/cli/types.ts

@@ -1,26 +1,46 @@
 export enum CliCommand {
   Run = 'run',
+  Add = 'add',
   Status = 'status',
+  Questions = 'questions',
+  Answer = 'answer',
   Resume = 'resume',
   Stop = 'stop',
   Delete = 'delete',
   Cleanup = 'cleanup',
-  Rollback = 'rollback',
   Init = 'init',
   Dashboard = 'dashboard',
+  Collision = 'collision',
   Retry = 'retry',
+  Merge = 'merge',
   Send = 'send',
   Attach = 'attach',
   Help = 'help',
+  Replay = 'replay',
+  Rollback = 'rollback',
+  Completion = 'completion',
+  InternalComplete = '__complete',
 }
 
 export interface CliOptions {
   command: CliCommand | string;
   file_input?: string;
   folder_input?: string;
+  no_resume?: boolean;
+  resume_feature_id?: string;
   feature_id?: string;
+  with_feature_id?: string;
+  reason?: string;
+  override_id?: string;
   message?: string;
-  checkpoint?: string;
+  answer?: string;
+  answered_by?: string;
+  question_id?: string;
+  question_status?: 'open' | 'answered' | 'expired' | 'withdrawn' | 'all';
+  approval_token?: string;
+  sync_remote?: string;
+  merge_strategy?: string;
+  commit_message?: string;
   dry_run?: boolean;
   yes?: boolean;
   remove_worktree?: boolean;
@@ -30,7 +50,6 @@ export interface CliOptions {
   agent_config?: string;
   provider_config_env?: string;
   worker_provider_mode?: 'live' | 'stub';
-  execution_mode?: 'deterministic' | 'interactive';
   transport?: string;
   takeover_stale_run?: boolean;
   batch?: boolean;
@@ -43,6 +62,18 @@ export interface CliOptions {
   port?: number;
   foreground?: boolean;
   dev?: boolean;
+  run_id?: string;
+  from_sequence?: number;
+  limit?: number;
+  tool_filter?: string;
+  json_output?: boolean;
+  checkpoint?: string;
+  allow?: boolean;
+  list?: boolean;
+  revoke?: boolean;
+  resume_after_collision_override?: boolean;
+  execution_mode?: 'deterministic' | 'interactive';
+  shell?: string;
 }
 
 export type RemoveBranchMode = 'none' | 'safe' | 'force';
@@ -63,3 +94,10 @@ export interface FeatureStatePayload {
 export interface DiscoveredSpecsPayload {
   specs: Array<{ spec_path: string }>;
 }
+
+export interface PreparedSpecItem {
+  feature_id: string;
+  source_path: string;
+  canonical_spec_path: string;
+  source_hash: string;
+}

package/apps/control-plane/src/core/collisions.ts

@@ -1,6 +1,6 @@
 import { stableHash } from './fs.js';
 
-interface PlanShape {
+export interface PlanShape {
   feature_id: string;
   files?: {
     create?: string[];
@@ -15,11 +15,151 @@ interface PlanShape {
   };
 }
 
-interface PolicyShape {
+export interface PolicyShape {
   exclusive_areas?: string[];
   protected_areas?: string[];
 }
 
+export interface PlanCollisionFilesEntry {
+  with_feature_id: string;
+  paths: string[];
+}
+
+export interface PlanCollisionAreasEntry {
+  with_feature_id: string;
+  overlaps: Array<[string, string]>;
+}
+
+export interface PlanCollisionContractsEntry {
+  with_feature_id: string;
+  contract: string;
+  candidate_mode: string;
+  other_mode: string;
+}
+
+export interface PlanCollisionsShape {
+  files: PlanCollisionFilesEntry[];
+  areas: PlanCollisionAreasEntry[];
+  contracts: PlanCollisionContractsEntry[];
+}
+
+export interface PlanCollisionPair {
+  with_feature_id: string;
+  collisions: PlanCollisionsShape;
+  fingerprint: string;
+  approved_paths: string[];
+}
+
+function sortStrings(values: string[]): string[] {
+  return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+
+function sortOverlapPairs(overlaps: Array<[string, string]>): Array<[string, string]> {
+  return [...overlaps].sort(
+    ([leftA, rightA], [leftB, rightB]) =>
+      leftA.localeCompare(leftB) || rightA.localeCompare(rightB),
+  );
+}
+
+export function emptyPlanCollisions(): PlanCollisionsShape {
+  return {
+    files: [],
+    areas: [],
+    contracts: [],
+  };
+}
+
+export function normalizePlanCollisions(collisions: PlanCollisionsShape): PlanCollisionsShape {
+  return {
+    files: [...collisions.files]
+      .map((entry) => ({
+        with_feature_id: entry.with_feature_id,
+        paths: sortStrings(entry.paths),
+      }))
+      .sort((left, right) => left.with_feature_id.localeCompare(right.with_feature_id)),
+    areas: [...collisions.areas]
+      .map((entry) => ({
+        with_feature_id: entry.with_feature_id,
+        overlaps: sortOverlapPairs(entry.overlaps),
+      }))
+      .sort((left, right) => left.with_feature_id.localeCompare(right.with_feature_id)),
+    contracts: [...collisions.contracts]
+      .map((entry) => ({
+        with_feature_id: entry.with_feature_id,
+        contract: entry.contract,
+        candidate_mode: entry.candidate_mode,
+        other_mode: entry.other_mode,
+      }))
+      .sort(
+        (left, right) =>
+          left.with_feature_id.localeCompare(right.with_feature_id) ||
+          left.contract.localeCompare(right.contract) ||
+          left.candidate_mode.localeCompare(right.candidate_mode) ||
+          left.other_mode.localeCompare(right.other_mode),
+      ),
+  };
+}
+
+export function createCollisionFingerprint(
+  featureId: string,
+  collisions: PlanCollisionsShape,
+): string {
+  return stableHash(
+    JSON.stringify({
+      feature_id: featureId,
+      collisions: normalizePlanCollisions(collisions),
+    }),
+  );
+}
+
+export function collectCollisionFeatureIds(collisions: PlanCollisionsShape): string[] {
+  return sortStrings([
+    ...collisions.files.map((entry) => entry.with_feature_id),
+    ...collisions.areas.map((entry) => entry.with_feature_id),
+    ...collisions.contracts.map((entry) => entry.with_feature_id),
+  ]);
+}
+
+export function hasPlanCollisions(collisions: PlanCollisionsShape): boolean {
+  return (
+    collisions.files.length > 0 || collisions.areas.length > 0 || collisions.contracts.length > 0
+  );
+}
+
+export function hasContractCollisions(collisions: PlanCollisionsShape): boolean {
+  return collisions.contracts.length > 0;
+}
+
+export function collectApprovedPaths(collisions: PlanCollisionsShape): string[] {
+  return sortStrings(collisions.files.flatMap((entry) => entry.paths));
+}
+
+export function collisionSubsetForFeature(
+  collisions: PlanCollisionsShape,
+  withFeatureId: string,
+): PlanCollisionsShape {
+  return normalizePlanCollisions({
+    files: collisions.files.filter((entry) => entry.with_feature_id === withFeatureId),
+    areas: collisions.areas.filter((entry) => entry.with_feature_id === withFeatureId),
+    contracts: collisions.contracts.filter((entry) => entry.with_feature_id === withFeatureId),
+  });
+}
+
+export function splitPlanCollisionsByFeature(
+  featureId: string,
+  collisions: PlanCollisionsShape,
+): PlanCollisionPair[] {
+  return collectCollisionFeatureIds(collisions).map((withFeatureId) => {
+    const subset = collisionSubsetForFeature(collisions, withFeatureId);
+    return {
+      with_feature_id: withFeatureId,
+      collisions: subset,
+      fingerprint: createCollisionFingerprint(featureId, subset),
+      approved_paths: collectApprovedPaths(subset),
+    };
+  });
+}
+
 function overlap(itemsA: string[], itemsB: string[]): string[] {
   const setB = new Set(itemsB);
   return itemsA.filter((item) => setB.has(item));
@@ -51,28 +191,10 @@ export function detectPlanCollisions(
   policy: PolicyShape,
 ): {
   hasCollisions: boolean;
-  collisions: {
-    files: Array<{ with_feature_id: string; paths: string[] }>;
-    areas: Array<{ with_feature_id: string; overlaps: Array<[string, string]> }>;
-    contracts: Array<{
-      with_feature_id: string;
-      contract: string;
-      candidate_mode: string;
-      other_mode: string;
-    }>;
-  };
+  collisions: PlanCollisionsShape;
   fingerprint: string | null;
 } {
-  const collisions = {
-    files: [] as Array<{ with_feature_id: string; paths: string[] }>,
-    areas: [] as Array<{ with_feature_id: string; overlaps: Array<[string, string]> }>,
-    contracts: [] as Array<{
-      with_feature_id: string;
-      contract: string;
-      candidate_mode: string;
-      other_mode: string;
-    }>,
-  };
+  const collisions = emptyPlanCollisions();
 
   const candidateFiles = collectPlanFiles(candidate);
 
@@ -122,17 +244,14 @@ export function detectPlanCollisions(
     }
   }
 
-  const hasCollisions =
-    collisions.files.length > 0 || collisions.areas.length > 0 || collisions.contracts.length > 0;
-
-  const fingerprintInput = JSON.stringify({
-    feature_id: candidate.feature_id,
-    collisions,
-  });
+  const normalizedCollisions = normalizePlanCollisions(collisions);
+  const hasCollisions = hasPlanCollisions(normalizedCollisions);
 
   return {
     hasCollisions,
-    collisions,
-    fingerprint: hasCollisions ? stableHash(fingerprintInput) : null,
+    collisions: normalizedCollisions,
+    fingerprint: hasCollisions
+      ? createCollisionFingerprint(candidate.feature_id, normalizedCollisions)
+      : null,
   };
 }