agentic-orchestrator 0.1.28 → 0.2.1

package/apps/control-plane/src/cli/dashboard-runtime.ts

@@ -0,0 +1,31 @@
+import {
+  computeInstanceId,
+  defaultConfigPath,
+} from '../application/services/instance-isolation-service.js';
+import { DashboardRuntimeRunner } from './dashboard-runtime-runner.js';
+
+function readFlag(name: string): string | null {
+  const index = process.argv.indexOf(name);
+  if (index === -1) {
+    return null;
+  }
+  const value = process.argv[index + 1];
+  return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
+}
+
+async function main(): Promise<void> {
+  const repoRoot = readFlag('--repo-root') ?? process.env.AOP_ROOT ?? process.cwd();
+  const instanceId = readFlag('--instance-id') ?? computeInstanceId(defaultConfigPath(repoRoot));
+  const runner = new DashboardRuntimeRunner({
+    repoRoot,
+    instanceId,
+    env: process.env,
+  });
+  await runner.start();
+}
+
+void main().catch((error: unknown) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(message);
+  process.exitCode = 1;
+});

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

@@ -1,195 +1,27 @@
-import { CliCommand } from './types.js';
-
-interface CommandHelp {
-  usage: string;
-  description: string;
-  flags?: Array<{ flag: string; description: string }>;
-}
-
-const COMMAND_HELP: Record<CliCommand, CommandHelp> = {
-  [CliCommand.Run]: {
-    usage: 'aop run [flags]',
-    description: 'Ingest spec files and start the agent supervisor.',
-    flags: [
-      { flag: '-fi <PATH>', description: 'Input spec file path' },
-      { flag: '-fl <PATH>', description: 'Input spec folder path' },
-      {
-        flag: '--batch',
-        description: 'Batch-ingest all specs in the folder (skip already-active features)',
-      },
-      {
-        flag: '--agent-provider <name>',
-        description: 'Override agent provider (claude, codex, gemini, …)',
-      },
-      { flag: '--agent-model <name>', description: 'Override agent model' },
-      { flag: '--agent-config <PATH>', description: 'Path to agent config file' },
-      {
-        flag: '--provider-config-env <var>',
-        description: 'Env var name used for API-backed provider auth/config',
-      },
-      {
-        flag: '--worker-provider-mode <live|stub>',
-        description: 'Worker execution mode override (default: live for run/resume)',
-      },
-      {
-        flag: '--execution-mode <deterministic|interactive>',
-        description: 'Execution mode override for worker decision flow (default: deterministic)',
-      },
-      { flag: '--transport <inprocess|mcp>', description: 'Tool transport layer (default: mcp)' },
-      { flag: '--takeover-stale-run', description: 'Take over a stale run lease' },
-      { flag: '--project <name>', description: 'Select project from multi-project.yaml' },
-    ],
-  },
-  [CliCommand.Status]: {
-    usage: 'aop status [flags]',
-    description: 'Show live status of all tracked features.',
-    flags: [
-      { flag: '--summary', description: 'Print a condensed one-line-per-feature summary' },
-      { flag: '--all', description: 'Aggregate status across all projects in multi-project.yaml' },
-      { flag: '--project <name>', description: 'Scope to a specific project' },
-    ],
-  },
-  [CliCommand.Resume]: {
-    usage: 'aop resume [flags]',
-    description: 'Resume blocked or stalled features.',
-    flags: [
-      { flag: '--feature-id <id>', description: 'Resume a specific feature' },
-      { flag: '--force', description: 'Force-resume even if the feature is not blocked' },
-      {
-        flag: '--worker-provider-mode <live|stub>',
-        description: 'Worker execution mode override (default: live)',
-      },
-      {
-        flag: '--execution-mode <deterministic|interactive>',
-        description: 'Execution mode override for worker decision flow (default: deterministic)',
-      },
-      { flag: '--transport <inprocess|mcp>', description: 'Tool transport layer (default: mcp)' },
-    ],
-  },
-  [CliCommand.Stop]: {
-    usage: 'aop stop [flags]',
-    description: 'Stop the dashboard server by terminating listeners on a target port.',
-    flags: [
-      { flag: '--port <number>', description: 'Port to stop (default: 3000)' },
-      { flag: '--project <name>', description: 'Use the project default dashboard port' },
-    ],
-  },
-  [CliCommand.Delete]: {
-    usage: 'aop delete [flags]',
-    description: 'Delete one or all features from the index (preview-only unless --yes is set).',
-    flags: [
-      { flag: '--feature-id <id>', description: 'Feature to delete' },
-      { flag: '--all', description: 'Delete all features' },
-      { flag: '--dry-run', description: 'Preview what would be deleted without making changes' },
-      { flag: '--yes', description: 'Required to apply destructive deletion' },
-    ],
-  },
-  [CliCommand.Cleanup]: {
-    usage: 'aop cleanup [flags]',
-    description: 'Clean up merged or stale feature state and worktrees.',
-    flags: [
-      { flag: '--feature-id <id>', description: 'Clean up a specific feature' },
-      { flag: '--all', description: 'Clean up all eligible features' },
-      { flag: '--remove-worktree', description: 'Remove the git worktree after cleanup' },
-      {
-        flag: '--remove-branch <none|safe|force>',
-        description: 'Branch removal mode after cleanup',
-      },
-      { flag: '--dry-run', description: 'Preview what would be cleaned without making changes' },
-      { flag: '--yes', description: 'Skip confirmation prompts' },
-      {
-        flag: '--force',
-        description:
-          'Force cleanup of features with expired leases regardless of status (e.g. after a timeout)',
-      },
-    ],
-  },
-  [CliCommand.Rollback]: {
-    usage: 'aop rollback [flags]',
-    description: 'Rollback a feature worktree by applying the inverse of a checkpoint snapshot.',
-    flags: [
-      { flag: '--feature-id <id>', description: 'Feature to roll back' },
-      { flag: '--checkpoint <id>', description: 'Checkpoint id to reverse-apply' },
-      { flag: '--dry-run', description: 'Preview rollback inputs without applying git changes' },
-    ],
-  },
-  [CliCommand.Init]: {
-    usage: 'aop init [flags]',
-    description: 'Initialise agentic orchestrator configuration in the current directory.',
-    flags: [
-      { flag: '--auto', description: 'Run non-interactively with defaults' },
-      { flag: '--force', description: 'Overwrite existing configuration' },
-      {
-        flag: '--advanced-policy',
-        description:
-          'Generate full explicit policy.yaml with all advanced controls (default: lean policy)',
-      },
-    ],
-  },
-  [CliCommand.Dashboard]: {
-    usage: 'aop dashboard [flags]',
-    description: 'Start the web dashboard server.',
-    flags: [
-      { flag: '--port <number>', description: 'Port to listen on (default: 3000)' },
-      { flag: '--foreground', description: 'Keep the server in the foreground' },
-      { flag: '--dev', description: 'Start in Next.js dev mode' },
-    ],
-  },
-  [CliCommand.Retry]: {
-    usage: 'aop retry [flags]',
-    description: 'Retry a failed gate or step for a feature.',
-    flags: [
-      { flag: '--feature-id <id>', description: 'Feature to retry' },
-      { flag: '--force', description: 'Force retry even if the feature is not in a failed state' },
-    ],
-  },
-  [CliCommand.Send]: {
-    usage: 'aop send <feature-id> <message>',
-    description: 'Send a message to an active agent for a feature.',
-    flags: [
-      {
-        flag: '--feature-id <id>',
-        description: 'Target feature (can also be the first positional argument)',
-      },
-      {
-        flag: '--message <text>',
-        description: 'Message to deliver (can also be the remaining positional arguments)',
-      },
-    ],
-  },
-  [CliCommand.Attach]: {
-    usage: 'aop attach <feature-id>',
-    description: 'Attach to the running agent session for a feature (interactive).',
-    flags: [
-      {
-        flag: '--feature-id <id>',
-        description: 'Feature to attach to (can also be the first positional argument)',
-      },
-    ],
-  },
-  [CliCommand.Help]: {
-    usage: 'aop help [command]',
-    description: 'Show this help text, or detailed help for a specific command.',
-    flags: [{ flag: '--help, -h', description: 'Can also be used with any command' }],
-  },
-};
+import type { CliCommand } from './types.js';
+import { COMMAND_CATALOG } from './command-catalog.js';
+import type { CommandDef } from './command-catalog.js';
+import { formatFlagUsage } from './command-catalog.js';
 
 function pad(str: string, width: number): string {
   return str + ' '.repeat(Math.max(0, width - str.length));
 }
 
-function renderCommand(cmd: CliCommand, help: CommandHelp): string {
+function renderCommand(cmd: CliCommand, help: CommandDef): string {
   const lines: string[] = [`  ${pad(cmd, 12)}${help.description}`];
   return lines.join('\n');
 }
 
-function renderCommandDetail(help: CommandHelp): string {
+function renderCommandDetail(help: CommandDef): string {
   const lines: string[] = [`Usage: ${help.usage}`, '', `  ${help.description}`];
   if (help.flags && help.flags.length > 0) {
     lines.push('', 'Flags:');
-    const colWidth = Math.max(...help.flags.map((f) => f.flag.length)) + 4;
-    for (const { flag, description } of help.flags) {
-      lines.push(`  ${pad(flag, colWidth)}${description}`);
+    const usages = help.flags.map((flag) => formatFlagUsage(flag));
+    const colWidth = Math.max(...usages.map((usage) => usage.length)) + 4;
+    for (let index = 0; index < help.flags.length; index += 1) {
+      const usage = usages[index];
+      const { description } = help.flags[index];
+      lines.push(`  ${pad(usage, colWidth)}${description}`);
     }
   }
   return lines.join('\n');
@@ -199,8 +31,8 @@ export class HelpCommandHandler {
   execute(subcommand?: string): { ok: boolean; data: { help: string } } {
     const target = subcommand as CliCommand | undefined;
 
-    if (target && target in COMMAND_HELP) {
-      const help = renderCommandDetail(COMMAND_HELP[target]);
+    if (target && target in COMMAND_CATALOG && !COMMAND_CATALOG[target].hidden) {
+      const help = renderCommandDetail(COMMAND_CATALOG[target]);
       return { ok: true, data: { help } };
     }
 
@@ -212,9 +44,9 @@ export class HelpCommandHandler {
       'Commands:',
     ];
 
-    const commandLines = (Object.entries(COMMAND_HELP) as Array<[CliCommand, CommandHelp]>).map(
-      ([cmd, help]) => renderCommand(cmd, help),
-    );
+    const commandLines = (Object.entries(COMMAND_CATALOG) as Array<[CliCommand, CommandDef]>)
+      .filter(([, def]) => !def.hidden)
+      .map(([cmd, help]) => renderCommand(cmd, help));
 
     const footer = [
       '',

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

@@ -197,6 +197,7 @@ dashboard:
   port: ${wizard.dashboardPort}
 merge_policy:
   require_user_approval: true
+  merge_target: base_branch
 notifications:
   enabled: ${notificationsEnabled}
   channels:
@@ -292,6 +293,7 @@ merge_policy:
     - merge_commit
     - squash
     - rebase
+  merge_target: base_branch
 worktree:
   base_branch: ${context.defaultBranch}
 rbac:
@@ -302,6 +304,11 @@ rbac:
     - feature.state_get
     - feature.state_patch
     - feature.log_append
+    - feature.question_create
+    - feature.question_list
+    - feature.question_answer
+    - feature.send_message
+    - feature.intake_submit
     - plan.submit
     - plan.get
     - plan.update
@@ -311,6 +318,7 @@ rbac:
     - repo.diff
     - repo.read_file
     - repo.search
+    - repo.reconcile_mainline
     - gates.list
     - gates.run
     - evidence.latest
@@ -324,7 +332,10 @@ rbac:
   planner:
     - feature.get_context
     - feature.state_get
+    - feature.question_create
+    - feature.intake_submit
     - plan.submit
+    - plan.get
     - plan.update
     - collisions.scan
     - repo.read_file
@@ -332,6 +343,7 @@ rbac:
   builder:
     - feature.get_context
     - feature.state_get
+    - feature.question_create
     - repo.apply_patch
     - repo.status
     - repo.diff
@@ -356,8 +368,13 @@ supervisor:
   max_iterations_per_phase: 6
   max_parallel_gate_runs: ${wizard.maxParallelGateRuns}
 cleanup:
-  auto_after_merge: false
-  grace_period_seconds: 3600
+  auto_after_merge:
+    worktree:
+      enabled: false
+      grace_period_seconds: 3600
+    aop:
+      enabled: false
+      grace_period_seconds: 3600
 dashboard:
   enabled: true
   port: ${wizard.dashboardPort}
@@ -373,6 +390,31 @@ notifications:
     webhook:
       enabled: ${wizard.notifications.webhook}
       url: "${escapeYamlString(wizard.notifications.webhookUrl)}"
+# Feature flags for experimental and preview capabilities
+innovation:
+  # Master toggle for replay timeline debugger (also requires observability.replay.enabled=true)
+  replay_debugger: true
+  # Master toggle for tamper-evident evidence chains
+  tamper_evident_evidence: false
+# Observability and replay timeline settings
+observability:
+  raw_agent_logs_enabled: false
+  raw_agent_logs_retention_days: 7
+  replay:
+    enabled: true
+    write_mode: best_effort  # best_effort | required
+    retention:
+      max_runs: 100
+      max_entries_per_run: 50000
+  evidence_integrity:
+    enabled: false
+    verify_on_read: false
+    algorithm_version: 1
+# Diagnostic tools configuration
+diagnostics:
+  doctor:
+    enabled: true
+    strict_fails_on: critical  # critical | warning
 `;
 }
 
@@ -417,15 +459,21 @@ function generateAgentsYaml(wizard: WizardConfig): string {
 roles:
   planner:
     system_prompt_path: config/agentic/orchestrator/prompts/planner.system.md
+    intake_system_prompt_path: config/agentic/orchestrator/prompts/planner-intake.system.md
   builder:
     system_prompt_path: config/agentic/orchestrator/prompts/builder.system.md
   qa:
     system_prompt_path: config/agentic/orchestrator/prompts/qa.system.md
+  reconciler:
+    system_prompt_path: config/agentic/orchestrator/prompts/reconciler.system.md
+  organizer:
+    system_prompt_path: config/agentic/orchestrator/prompts/organizer.system.md
 missing_prompt_behavior: ignore
 runtime:
   default_provider: ${wizard.defaultProvider}
   default_model: ${wizard.defaultModel}
   execution_mode: ${wizard.executionMode}
+  prompt_overlay_dir: config/agentic/orchestrator/prompts/overrides
   interactive:
     watchdog_poll_interval_ms: 2000
     checkpoint_interval_ms: 30000
@@ -565,10 +613,7 @@ function parseYesNo(raw: string, fallback: boolean): boolean {
   return fallback;
 }
 
-function defaultProviderConfigEnvName(provider: string): string {
-  if (provider === 'gemini') {
-    return 'GEMINI_API_KEY';
-  }
+function defaultProviderConfigEnvName(_provider: string): string {
   return 'AOP_PROVIDER_CONFIG_ENV';
 }
 

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

@@ -0,0 +1,200 @@
+import { ERROR_CODES } from '../core/error-codes.js';
+import { TOOLS } from '../core/constants.js';
+import type { AppError } from '../providers/providers.js';
+import type { ToolClient } from '../mcp/tool-client.js';
+import type { CliOptions } from './types.js';
+import { callCliTool } from './tooling.js';
+
+const VALID_STRATEGIES = ['merge_commit', 'squash', 'rebase'] as const;
+type MergeStrategy = (typeof VALID_STRATEGIES)[number];
+
+interface FeatureStatePayload {
+  front_matter: {
+    version: number;
+    status?: string;
+    gates?: {
+      merge?: string;
+    };
+    merge_repair?: {
+      attempts?: number;
+      max_attempts?: number;
+    };
+  };
+}
+
+interface GateRunPayload {
+  overall?: string;
+}
+
+interface ReconciliationPayload {
+  status?: 'up_to_date' | 'merged' | 'conflict_detected';
+  merge_base?: string;
+  mainline_head?: string;
+  worktree_head?: string;
+  conflicting_files?: string[];
+  reconciler_active_feature_id?: string | null;
+  reconciler_queue_position?: number | null;
+  dispatched_to_reconciler?: boolean;
+  conflict_worktree_prepared?: boolean;
+}
+
+function isValidFeatureId(value: string): boolean {
+  return /^[a-z0-9_][a-z0-9_-]*$/.test(value);
+}
+
+function isValidStrategy(value: string): value is MergeStrategy {
+  return (VALID_STRATEGIES as readonly string[]).includes(value);
+}
+
+function invalidCliArgs(details: Record<string, unknown>): never {
+  const error = new Error(ERROR_CODES.INVALID_CLI_ARGS) as AppError;
+  error.code = ERROR_CODES.INVALID_CLI_ARGS;
+  error.details = details;
+  throw error;
+}
+
+export class MergeCommandHandler {
+  private readonly toolClient: ToolClient;
+  private readonly runId: string;
+
+  constructor(toolClient: ToolClient, runId: string) {
+    this.toolClient = toolClient;
+    this.runId = runId;
+  }
+
+  async execute(options: CliOptions): Promise<unknown> {
+    const featureId = options.feature_id;
+    if (!featureId) {
+      invalidCliArgs({
+        reason: '--feature-id is required for merge',
+        expected: '--feature-id <feature_id>',
+      });
+    }
+    if (!isValidFeatureId(featureId)) {
+      invalidCliArgs({
+        reason: 'Invalid --feature-id value',
+        provided: featureId,
+        expected_pattern: '^[a-z0-9_][a-z0-9_-]*$',
+      });
+    }
+
+    const strategy = options.merge_strategy ?? 'merge_commit';
+    if (!isValidStrategy(strategy)) {
+      invalidCliArgs({
+        reason: 'Invalid --strategy value',
+        provided: strategy,
+        expected: VALID_STRATEGIES,
+      });
+    }
+
+    const commitMessage = options.commit_message ?? `Merge feature ${featureId}`;
+    const approvalToken = options.approval_token ?? null;
+    const syncRemote = options.sync_remote ?? 'auto';
+
+    // Run the merge gate automatically if it hasn't passed yet.
+    const state = await callCliTool(this.toolClient, this.runId, TOOLS.FEATURE_STATE_GET, {
+      feature_id: featureId,
+    });
+    const statePayload = state.data as unknown as FeatureStatePayload;
+    const mergeGatePassed = statePayload.front_matter.gates?.merge === 'pass';
+
+    const reconciliation = await callCliTool(
+      this.toolClient,
+      this.runId,
+      TOOLS.REPO_RECONCILE_MAINLINE,
+      {
+        feature_id: featureId,
+        commit_message: commitMessage,
+        auto_merge_non_conflicting: true,
+        ...(syncRemote ? { remote_sync_strategy: syncRemote } : {}),
+      },
+    );
+    const reconciliationPayload = reconciliation.data as unknown as ReconciliationPayload;
+
+    if (reconciliationPayload.status === 'conflict_detected') {
+      return {
+        ok: false,
+        error: {
+          code: ERROR_CODES.RECONCILIATION_FAILED,
+          message: 'Merge requires reconciler intervention before it can continue',
+          details: {
+            feature_id: featureId,
+            merge_base: reconciliationPayload.merge_base ?? null,
+            mainline_head: reconciliationPayload.mainline_head ?? null,
+            worktree_head: reconciliationPayload.worktree_head ?? null,
+            conflicting_files: reconciliationPayload.conflicting_files ?? [],
+            reconciler_active_feature_id:
+              reconciliationPayload.reconciler_active_feature_id ?? null,
+            reconciler_queue_position: reconciliationPayload.reconciler_queue_position ?? null,
+            dispatched_to_reconciler: reconciliationPayload.dispatched_to_reconciler ?? false,
+            conflict_worktree_prepared: reconciliationPayload.conflict_worktree_prepared ?? false,
+            retryable: false,
+            requires_human: true,
+          },
+        },
+      };
+    }
+
+    const mustRunMergeGate = !mergeGatePassed || reconciliationPayload.status === 'merged';
+    let gateResult: GateRunPayload | null = null;
+    if (mustRunMergeGate) {
+      const gate = await callCliTool(this.toolClient, this.runId, TOOLS.GATES_RUN, {
+        feature_id: featureId,
+        mode: 'merge',
+      });
+      gateResult = gate.data as GateRunPayload;
+      if (gateResult.overall !== 'pass') {
+        const failedState = await callCliTool(
+          this.toolClient,
+          this.runId,
+          TOOLS.FEATURE_STATE_GET,
+          {
+            feature_id: featureId,
+          },
+        );
+        const failedStatePayload = failedState.data as unknown as FeatureStatePayload;
+        return {
+          ok: false,
+          error: {
+            code: ERROR_CODES.MERGE_DISABLED,
+            message: 'Merge gate did not pass — merge aborted',
+            details: {
+              feature_id: featureId,
+              gate_overall: gateResult.overall,
+              reconciliation_status: reconciliationPayload.status ?? null,
+              reconciliation_attempted: true,
+              recovery_available: failedStatePayload.front_matter.status !== 'failed',
+              status_after_gate_failure: failedStatePayload.front_matter.status ?? null,
+              merge_repair_attempts: failedStatePayload.front_matter.merge_repair?.attempts ?? null,
+              merge_repair_max_attempts:
+                failedStatePayload.front_matter.merge_repair?.max_attempts ?? null,
+              retryable: true,
+              requires_human: false,
+            },
+          },
+        };
+      }
+    }
+
+    const result = await callCliTool(this.toolClient, this.runId, TOOLS.FEATURE_READY_TO_MERGE, {
+      feature_id: featureId,
+      commit_message: commitMessage,
+      merge_strategy: strategy,
+      user_approval_token: approvalToken ?? '',
+      ...(syncRemote ? { remote_sync_strategy: syncRemote } : {}),
+    });
+
+    const resultData = result.data;
+
+    return {
+      ok: true,
+      data: {
+        command: 'merge',
+        merge_gate_run: mustRunMergeGate,
+        merge_gate_overall: mustRunMergeGate ? (gateResult?.overall ?? null) : 'pass',
+        reconciliation_status: reconciliationPayload.status ?? null,
+        ...(resultData ?? {}),
+      },
+    };
+  }
+}

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

@@ -0,0 +1,70 @@
+import { ERROR_CODES } from '../core/error-codes.js';
+import { TOOLS } from '../core/constants.js';
+import type { AppError } from '../providers/providers.js';
+import type { ToolClient } from '../mcp/tool-client.js';
+import type { CliOptions } from './types.js';
+import { callCliTool } from './tooling.js';
+
+const QUESTION_STATUSES = new Set(['open', 'answered', 'expired', 'withdrawn', 'all']);
+
+function isValidFeatureId(value: string): boolean {
+  return /^[a-z0-9_][a-z0-9_-]*$/.test(value);
+}
+
+function invalidCliArgs(details: Record<string, unknown>): never {
+  const error = new Error(ERROR_CODES.INVALID_CLI_ARGS) as AppError;
+  error.code = ERROR_CODES.INVALID_CLI_ARGS;
+  error.details = details;
+  throw error;
+}
+
+export class QuestionsCommandHandler {
+  private readonly toolClient: ToolClient;
+  private readonly runId: string;
+
+  constructor(toolClient: ToolClient, runId: string) {
+    this.toolClient = toolClient;
+    this.runId = runId;
+  }
+
+  async execute(options: CliOptions): Promise<unknown> {
+    const featureId = options.feature_id;
+    if (!featureId) {
+      invalidCliArgs({
+        reason: '--feature-id is required for questions',
+        expected: '--feature-id <feature_id>',
+      });
+    }
+    if (!isValidFeatureId(featureId)) {
+      invalidCliArgs({
+        reason: 'Invalid --feature-id value',
+        provided: featureId,
+        expected_pattern: '^[a-z0-9_][a-z0-9_-]*$',
+      });
+    }
+
+    const status = options.question_status ?? 'open';
+    if (!QUESTION_STATUSES.has(status)) {
+      invalidCliArgs({
+        reason: 'Invalid --status value',
+        provided: status,
+        expected: ['open', 'answered', 'expired', 'withdrawn', 'all'],
+      });
+    }
+
+    const response = await callCliTool(this.toolClient, this.runId, TOOLS.FEATURE_QUESTION_LIST, {
+      feature_id: featureId,
+      status,
+    });
+
+    return {
+      ok: true,
+      data: {
+        command: 'questions',
+        feature_id: featureId,
+        status,
+        ...(response.data ?? {}),
+      },
+    };
+  }
+}