oh-pi 0.1.0

package/pi-package/extensions/ant-colony/queen.ts

@@ -0,0 +1,356 @@
+/**
+ * 蚁后 (Queen) — 蚁群调度核心
+ *
+ * 生命周期：
+ * 1. 接收目标 → 派侦察蚁探路
+ * 2. 侦察蚁返回 → 根据发现生成任务池
+ * 3. 自适应派工蚁执行任务
+ * 4. 任务完成 → 派兵蚁审查
+ * 5. 有问题 → 生成修复任务回到步骤3
+ * 6. 全部通过 → 汇总报告
+ *
+ * 调度循环模拟真实蚁群：蚂蚁不断出巢→觅食→回巢→再出巢
+ */
+
+import type {
+  ColonyState, Task, Ant, AntCaste, ColonyMetrics,
+  ConcurrencyConfig, TaskPriority,
+} from "./types.js";
+import { DEFAULT_ANT_CONFIGS } from "./types.js";
+import { Nest } from "./nest.js";
+import { spawnAnt, makeTaskId } from "./spawner.js";
+import { adapt, sampleSystem, defaultConcurrency } from "./concurrency.js";
+
+export interface QueenCallbacks {
+  onPhase(phase: ColonyState["status"], detail: string): void;
+  onAntSpawn(ant: Ant, task: Task): void;
+  onAntDone(ant: Ant, task: Task, output: string): void;
+  onProgress(metrics: ColonyMetrics): void;
+  onComplete(state: ColonyState): void;
+}
+
+export interface QueenOptions {
+  cwd: string;
+  goal: string;
+  maxAnts?: number;
+  signal?: AbortSignal;
+  callbacks: QueenCallbacks;
+}
+
+function makeColonyId(): string {
+  return `colony-${Date.now().toString(36)}`;
+}
+
+function makeInitialScoutTask(goal: string): Task {
+  return {
+    id: makeTaskId(),
+    parentId: null,
+    title: "Scout: explore codebase for goal",
+    description: `Explore the codebase and identify all files, modules, and dependencies relevant to this goal:\n\n${goal}\n\nBe thorough. The colony depends on your intelligence.`,
+    caste: "scout",
+    status: "pending",
+    priority: 1,
+    files: [],
+    claimedBy: null,
+    result: null,
+    error: null,
+    spawnedTasks: [],
+    createdAt: Date.now(),
+    startedAt: null,
+    finishedAt: null,
+  };
+}
+
+function childTaskFromParsed(
+  parentId: string,
+  parsed: { title: string; description: string; files: string[]; caste: AntCaste; priority: TaskPriority },
+): Task {
+  return {
+    id: makeTaskId(),
+    parentId,
+    title: parsed.title,
+    description: parsed.description,
+    caste: parsed.caste,
+    status: "pending",
+    priority: parsed.priority,
+    files: parsed.files,
+    claimedBy: null,
+    result: null,
+    error: null,
+    spawnedTasks: [],
+    createdAt: Date.now(),
+    startedAt: null,
+    finishedAt: null,
+  };
+}
+
+function makeReviewTask(completedTasks: Task[]): Task {
+  const files = [...new Set(completedTasks.flatMap(t => t.files))];
+  return {
+    id: makeTaskId(),
+    parentId: null,
+    title: "Soldier: review all changes",
+    description: `Review all changes made by worker ants. Files changed:\n${files.map(f => `- ${f}`).join("\n")}`,
+    caste: "soldier",
+    status: "pending",
+    priority: 1,
+    files,
+    claimedBy: null,
+    result: null,
+    error: null,
+    spawnedTasks: [],
+    createdAt: Date.now(),
+    startedAt: null,
+    finishedAt: null,
+  };
+}
+
+function updateMetrics(nest: Nest): ColonyMetrics {
+  const tasks = nest.getAllTasks();
+  const state = nest.getState();
+  const now = Date.now();
+  const elapsed = (now - state.metrics.startTime) / 60000; // minutes
+
+  const metrics: ColonyMetrics = {
+    tasksTotal: tasks.length,
+    tasksDone: tasks.filter(t => t.status === "done").length,
+    tasksFailed: tasks.filter(t => t.status === "failed").length,
+    antsSpawned: state.ants.length,
+    totalCost: state.ants.reduce((s, a) => s + a.usage.cost, 0),
+    totalTokens: state.ants.reduce((s, a) => s + a.usage.input + a.usage.output, 0),
+    startTime: state.metrics.startTime,
+    throughputHistory: [
+      ...state.metrics.throughputHistory,
+      elapsed > 0 ? tasks.filter(t => t.status === "done").length / elapsed : 0,
+    ].slice(-20),
+  };
+
+  nest.updateState({ metrics });
+  return metrics;
+}
+
+/**
+ * 并发执行一批蚂蚁，自适应调节并发度
+ */
+async function runAntWave(
+  nest: Nest,
+  cwd: string,
+  caste: AntCaste,
+  signal: AbortSignal | undefined,
+  callbacks: QueenCallbacks,
+): Promise<void> {
+  const config = DEFAULT_ANT_CONFIGS[caste];
+
+  let backoffMs = 0; // 429 退避时间
+
+  const runOne = async (): Promise<"done" | "empty" | "rate_limited"> => {
+    const task = nest.nextPendingTask(caste);
+    if (!task) return "empty";
+    if (!nest.claimTask(task.id, "queen")) return "empty";
+
+    const ant: Ant = {
+      id: "", caste, status: "idle", taskId: task.id,
+      pid: null, usage: { input: 0, output: 0, cost: 0, turns: 0 },
+      startedAt: Date.now(), finishedAt: null,
+    };
+    callbacks.onAntSpawn(ant, task);
+
+    try {
+      const result = await spawnAnt(cwd, nest, task, config, signal);
+      callbacks.onAntDone(result.ant, task, result.output);
+
+      if (result.rateLimited) {
+        return "rate_limited";
+      }
+
+      // 蚂蚁产生的子任务加入巢穴
+      for (const sub of result.newTasks) {
+        // 检查文件锁冲突
+        const allTasks = nest.getAllTasks();
+        const conflicting = allTasks.find(t =>
+          t.status === "active" &&
+          t.files.some(f => sub.files.includes(f))
+        );
+        const child = childTaskFromParsed(task.id, sub);
+        if (conflicting) {
+          child.status = "blocked";
+        }
+        nest.addSubTask(task.id, child);
+      }
+
+      // 更新指标
+      const metrics = updateMetrics(nest);
+      callbacks.onProgress(metrics);
+
+      return "done";
+    } catch (e) {
+      nest.updateTaskStatus(task.id, "failed", undefined, String(e));
+      return "done";
+    }
+  };
+
+  // 调度循环：持续派蚂蚁直到没有待处理任务
+  while (!signal?.aborted) {
+    const state = nest.getState();
+    const pending = state.tasks.filter(t => t.status === "pending" && t.caste === caste);
+    if (pending.length === 0) break;
+
+    // 429 退避：等待后恢复
+    if (backoffMs > 0) {
+      callbacks.onPhase("working", `Rate limited (429). Backing off ${Math.round(backoffMs / 1000)}s...`);
+      await new Promise(r => setTimeout(r, backoffMs));
+      backoffMs = 0;
+    }
+
+    // 解除 blocked 任务（如果锁定文件已释放）
+    const activeTasks = state.tasks.filter(t => t.status === "active");
+    const activeFiles = new Set(activeTasks.flatMap(t => t.files));
+    for (const t of state.tasks.filter(t => t.status === "blocked" && t.caste === caste)) {
+      if (!t.files.some(f => activeFiles.has(f))) {
+        nest.updateTaskStatus(t.id, "pending");
+      }
+    }
+
+    // 自适应并发
+    const completedRecently = state.tasks.filter(t =>
+      t.status === "done" && t.finishedAt && t.finishedAt > Date.now() - 120000
+    ).length;
+    const sample = sampleSystem(
+      state.ants.filter(a => a.status === "working").length,
+      completedRecently,
+      2,
+    );
+    nest.recordSample(sample);
+
+    const concurrency = adapt(state.concurrency, pending.length);
+    nest.updateState({ concurrency });
+
+    // 派出蚂蚁（并发数由 adapt 决定）
+    const activeAnts = state.ants.filter(a => a.status === "working").length;
+    const slotsAvailable = Math.max(0, concurrency.current - activeAnts);
+
+    if (slotsAvailable === 0) {
+      // 等待一下再检查
+      await new Promise(r => setTimeout(r, 2000));
+      continue;
+    }
+
+    const batch = Math.min(slotsAvailable, pending.length);
+    const promises: Promise<"done" | "empty" | "rate_limited">[] = [];
+    for (let i = 0; i < batch; i++) {
+      promises.push(runOne());
+    }
+    const results = await Promise.all(promises);
+
+    // 429 处理：任何蚂蚁遇到限流 → 降低并发 + 指数退避
+    if (results.includes("rate_limited")) {
+      const cur = nest.getState().concurrency;
+      const reduced = Math.max(cur.min, Math.floor(cur.current / 2));
+      nest.updateState({ concurrency: { ...cur, current: reduced } });
+      // 指数退避：15s → 30s → 60s，上限 60s
+      backoffMs = backoffMs === 0 ? 15000 : Math.min(backoffMs * 2, 60000);
+    } else {
+      // 成功时逐步恢复退避计数
+      backoffMs = 0;
+    }
+  }
+}
+
+/**
+ * 蚁后主循环
+ */
+export async function runColony(opts: QueenOptions): Promise<ColonyState> {
+  const colonyId = makeColonyId();
+  const nest = new Nest(opts.cwd, colonyId);
+
+  const initialState: ColonyState = {
+    id: colonyId,
+    goal: opts.goal,
+    status: "scouting",
+    tasks: [makeInitialScoutTask(opts.goal)],
+    ants: [],
+    pheromones: [],
+    concurrency: defaultConcurrency(),
+    metrics: {
+      tasksTotal: 1, tasksDone: 0, tasksFailed: 0,
+      antsSpawned: 0, totalCost: 0, totalTokens: 0,
+      startTime: Date.now(), throughputHistory: [],
+    },
+    createdAt: Date.now(),
+    finishedAt: null,
+  };
+
+  if (opts.maxAnts) {
+    initialState.concurrency.max = opts.maxAnts;
+  }
+
+  nest.init(initialState);
+  const { signal, callbacks } = opts;
+
+  try {
+    // ═══ Phase 1: 侦察 ═══
+    callbacks.onPhase("scouting", "Dispatching scout ants to explore codebase...");
+    await runAntWave(nest, opts.cwd, "scout", signal, callbacks);
+
+    // 检查侦察结果，如果没有产生工蚁任务，用侦察结果让女王自己拆
+    const postScout = nest.getAllTasks();
+    const workerTasks = postScout.filter(t => t.caste === "worker" && t.status === "pending");
+    if (workerTasks.length === 0) {
+      // 侦察蚁没产生任务，标记失败
+      nest.updateState({ status: "failed", finishedAt: Date.now() });
+      const finalState = nest.getState();
+      callbacks.onComplete(finalState);
+      return finalState;
+    }
+
+    // ═══ Phase 2: 工作 ═══
+    nest.updateState({ status: "working" });
+    callbacks.onPhase("working", `${workerTasks.length} tasks discovered. Dispatching worker ants...`);
+    await runAntWave(nest, opts.cwd, "worker", signal, callbacks);
+
+    // 处理工蚁产生的子任务（可能有多轮）
+    let rounds = 0;
+    while (rounds < 3) {
+      const remaining = nest.getAllTasks().filter(t =>
+        t.caste === "worker" && (t.status === "pending" || t.status === "blocked")
+      );
+      if (remaining.length === 0) break;
+      rounds++;
+      callbacks.onPhase("working", `Round ${rounds + 1}: ${remaining.length} sub-tasks from workers...`);
+      await runAntWave(nest, opts.cwd, "worker", signal, callbacks);
+    }
+
+    // ═══ Phase 3: 审查 ═══
+    const completedWorkerTasks = nest.getAllTasks().filter(t => t.caste === "worker" && t.status === "done");
+    if (completedWorkerTasks.length > 0) {
+      nest.updateState({ status: "reviewing" });
+      callbacks.onPhase("reviewing", "Dispatching soldier ants to review changes...");
+      const reviewTask = makeReviewTask(completedWorkerTasks);
+      nest.writeTask(reviewTask);
+      await runAntWave(nest, opts.cwd, "soldier", signal, callbacks);
+
+      // 兵蚁产生的修复任务
+      const fixTasks = nest.getAllTasks().filter(t =>
+        t.caste === "worker" && t.status === "pending" && t.parentId !== null
+      );
+      if (fixTasks.length > 0) {
+        nest.updateState({ status: "working" });
+        callbacks.onPhase("working", `${fixTasks.length} fix tasks from review. Dispatching workers...`);
+        await runAntWave(nest, opts.cwd, "worker", signal, callbacks);
+      }
+    }
+
+    // ═══ Phase 4: 完成 ═══
+    const finalMetrics = updateMetrics(nest);
+    nest.updateState({ status: "done", finishedAt: Date.now(), metrics: finalMetrics });
+    const finalState = nest.getState();
+    callbacks.onComplete(finalState);
+    return finalState;
+
+  } catch (e) {
+    nest.updateState({ status: "failed", finishedAt: Date.now() });
+    const failState = nest.getState();
+    callbacks.onComplete(failState);
+    return failState;
+  }
+}

package/pi-package/extensions/ant-colony/spawner.ts

@@ -0,0 +1,328 @@
+/**
+ * 蚂蚁 Spawner — 每只蚂蚁是一个独立 pi --mode json 进程
+ *
+ * 蚂蚁的 system prompt 中注入：
+ * - 自己的角色和任务
+ * - 巢穴中的信息素上下文
+ * - 完成后输出结构化结果的指令
+ */
+
+import { spawn as nodeSpawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { Ant, AntCaste, AntConfig, Task, Pheromone, DEFAULT_ANT_CONFIGS } from "./types.js";
+import type { Nest } from "./nest.js";
+
+let antCounter = 0;
+
+export function makeAntId(caste: AntCaste): string {
+  return `${caste}-${++antCounter}-${Date.now().toString(36)}`;
+}
+
+export function makePheromoneId(): string {
+  return `p-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+}
+
+export function makeTaskId(): string {
+  return `t-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+}
+
+interface AntResult {
+  ant: Ant;
+  output: string;
+  messages: any[];
+  newTasks: ParsedSubTask[];
+  pheromones: Pheromone[];
+  rateLimited: boolean;
+}
+
+interface ParsedSubTask {
+  title: string;
+  description: string;
+  files: string[];
+  caste: AntCaste;
+  priority: 1 | 2 | 3 | 4 | 5;
+}
+
+const CASTE_PROMPTS: Record<AntCaste, string> = {
+  scout: `You are a Scout Ant. Your job is to explore and gather intelligence, NOT to make changes.
+
+Behavior:
+- Quickly scan the codebase to understand structure and locate relevant code
+- Identify files, functions, dependencies related to the goal
+- Report findings as structured intelligence for Worker Ants
+
+Output format (MUST follow exactly):
+## Discoveries
+- What you found, with file:line references
+
+## Recommended Tasks
+For each task the colony should do next:
+### TASK: <title>
+- description: <what to do>
+- files: <comma-separated file paths>
+- caste: worker
+- priority: <1-5, 1=highest>
+
+## Warnings
+Any risks, blockers, or conflicts detected.`,
+
+  worker: `You are a Worker Ant. You execute tasks autonomously and leave traces for the colony.
+
+Behavior:
+- Read the pheromone context to understand what scouts and other workers discovered
+- Execute your assigned task completely
+- If you discover sub-tasks needed, declare them (do NOT execute them yourself)
+- Minimize file conflicts — only touch files assigned to you
+
+Output format (MUST follow exactly):
+## Completed
+What was done, with file:line references for all changes.
+
+## Files Changed
+- path/to/file.ts — what changed
+
+## Sub-Tasks (if any)
+### TASK: <title>
+- description: <what to do>
+- files: <comma-separated file paths>
+- caste: <worker|soldier>
+- priority: <1-5>
+
+## Pheromone
+Key information other ants should know about your changes.`,
+
+  soldier: `You are a Soldier Ant (Reviewer). You guard colony quality — you do NOT make changes.
+
+Behavior:
+- Review the files changed by worker ants
+- Check for bugs, security issues, conflicts between workers
+- Report issues that need fixing
+
+Output format (MUST follow exactly):
+## Review
+- file:line — issue description (severity: critical|warning|info)
+
+## Fix Tasks (if critical issues found)
+### TASK: <title>
+- description: <what to fix>
+- files: <comma-separated file paths>
+- caste: worker
+- priority: 1
+
+## Verdict
+PASS or FAIL with summary.`,
+};
+
+function buildPrompt(task: Task, pheromoneContext: string, castePrompt: string): string {
+  let prompt = castePrompt + "\n\n";
+  if (pheromoneContext) {
+    prompt += `## Colony Pheromone Trail (intelligence from other ants)\n${pheromoneContext}\n\n`;
+  }
+  prompt += `## Your Assignment\n**Task:** ${task.title}\n**Description:** ${task.description}\n`;
+  if (task.files.length > 0) {
+    prompt += `**Files scope:** ${task.files.join(", ")}\n`;
+  }
+  return prompt;
+}
+
+function writePromptFile(antId: string, prompt: string): { dir: string; file: string } {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "ant-"));
+  const file = path.join(dir, `${antId}.md`);
+  fs.writeFileSync(file, prompt, { mode: 0o600 });
+  return { dir, file };
+}
+
+/** 从蚂蚁输出中解析子任务声明 */
+function parseSubTasks(output: string): ParsedSubTask[] {
+  const tasks: ParsedSubTask[] = [];
+  const regex = /### TASK:\s*(.+)\n(?:- description:\s*(.+)\n)?(?:- files:\s*(.+)\n)?(?:- caste:\s*(\w+)\n)?(?:- priority:\s*(\d))?/g;
+  for (const m of output.matchAll(regex)) {
+    tasks.push({
+      title: m[1]?.trim() || "Untitled",
+      description: m[2]?.trim() || m[1]?.trim() || "",
+      files: (m[3]?.trim() || "").split(",").map(f => f.trim()).filter(Boolean),
+      caste: (m[4]?.trim() as AntCaste) || "worker",
+      priority: (parseInt(m[5] || "3") as 1 | 2 | 3 | 4 | 5) || 3,
+    });
+  }
+  return tasks;
+}
+
+/** 从蚂蚁输出中提取信息素 */
+function extractPheromones(antId: string, caste: AntCaste, taskId: string, output: string, files: string[]): Pheromone[] {
+  const pheromones: Pheromone[] = [];
+  const now = Date.now();
+
+  // 提取 ## Discoveries 或 ## Pheromone 段落
+  const sections = ["Discoveries", "Pheromone", "Files Changed", "Warnings", "Review"];
+  for (const section of sections) {
+    const regex = new RegExp(`## ${section}\\n([\\s\\S]*?)(?=\\n## |$)`, "i");
+    const match = output.match(regex);
+    if (match?.[1]?.trim()) {
+      const type: import("./types.js").PheromoneType =
+        section === "Discoveries" ? "discovery" :
+        section === "Warnings" || section === "Review" ? "warning" :
+        section === "Files Changed" ? "completion" : "progress";
+      pheromones.push({
+        id: makePheromoneId(),
+        type,
+        antId,
+        antCaste: caste,
+        taskId,
+        content: match[1].trim().slice(0, 2000), // 限制大小
+        files,
+        strength: 1.0,
+        createdAt: now,
+      });
+    }
+  }
+  return pheromones;
+}
+
+/** 获取蚂蚁输出的最终文本 */
+function getFinalOutput(messages: any[]): string {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role === "assistant") {
+      for (const part of msg.content) {
+        if (part.type === "text") return part.text;
+      }
+    }
+  }
+  return "";
+}
+
+/**
+ * 孵化并运行一只蚂蚁
+ */
+export async function spawnAnt(
+  cwd: string,
+  nest: Nest,
+  task: Task,
+  antConfig: Omit<AntConfig, "systemPrompt">,
+  signal?: AbortSignal,
+): Promise<AntResult> {
+  const antId = makeAntId(antConfig.caste);
+  const ant: Ant = {
+    id: antId,
+    caste: antConfig.caste,
+    status: "working",
+    taskId: task.id,
+    pid: null,
+    usage: { input: 0, output: 0, cost: 0, turns: 0 },
+    startedAt: Date.now(),
+    finishedAt: null,
+  };
+
+  nest.updateAnt(ant);
+  nest.updateTaskStatus(task.id, "active");
+
+  // 构建 prompt
+  const pheromoneCtx = nest.getPheromoneContext(task.files);
+  const castePrompt = CASTE_PROMPTS[antConfig.caste];
+  const fullPrompt = buildPrompt(task, pheromoneCtx, castePrompt);
+  const { dir: tmpDir, file: tmpFile } = writePromptFile(antId, fullPrompt);
+
+  const args = [
+    "--mode", "json",
+    "-p",
+    "--no-session",
+    "--model", antConfig.model,
+    "--tools", antConfig.tools.join(","),
+    "--append-system-prompt", tmpFile,
+    `Execute this task: ${task.title}\n\n${task.description}`,
+  ];
+
+  const messages: any[] = [];
+  let stderr = "";
+
+  try {
+    const exitCode = await new Promise<number>((resolve) => {
+      const proc = nodeSpawn("pi", args, { cwd, shell: false, stdio: ["ignore", "pipe", "pipe"] });
+      ant.pid = proc.pid ?? null;
+      nest.updateAnt(ant);
+
+      let buffer = "";
+
+      proc.stdout.on("data", (data) => {
+        buffer += data.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const event = JSON.parse(line);
+            if (event.type === "message_end" && event.message) {
+              messages.push(event.message);
+              if (event.message.role === "assistant") {
+                ant.usage.turns++;
+                const u = event.message.usage;
+                if (u) {
+                  ant.usage.input += u.input || 0;
+                  ant.usage.output += u.output || 0;
+                  ant.usage.cost += u.cost?.total || 0;
+                }
+              }
+            }
+            if (event.type === "tool_result_end" && event.message) {
+              messages.push(event.message);
+            }
+          } catch { /* skip non-json */ }
+        }
+      });
+
+      proc.stderr.on("data", (d) => { stderr += d.toString(); });
+      proc.on("close", (code) => {
+        if (buffer.trim()) {
+          try {
+            const event = JSON.parse(buffer);
+            if (event.type === "message_end" && event.message) messages.push(event.message);
+          } catch { /* skip */ }
+        }
+        resolve(code ?? 1);
+      });
+      proc.on("error", () => resolve(1));
+
+      if (signal) {
+        const kill = () => {
+          proc.kill("SIGTERM");
+          setTimeout(() => { if (!proc.killed) proc.kill("SIGKILL"); }, 3000);
+        };
+        if (signal.aborted) kill();
+        else signal.addEventListener("abort", kill, { once: true });
+      }
+    });
+
+    const output = getFinalOutput(messages);
+    const success = exitCode === 0;
+    const rateLimited = stderr.includes("429") || stderr.includes("rate limit") || stderr.includes("Rate limit")
+      || output.includes("429") || output.includes("rate_limit");
+
+    ant.status = success ? "done" : "failed";
+    ant.finishedAt = Date.now();
+    ant.pid = null;
+    nest.updateAnt(ant);
+
+    if (rateLimited) {
+      // 429: 不标记任务为 failed，回退为 pending 以便重试
+      nest.updateTaskStatus(task.id, "pending");
+      ant.status = "failed";
+      nest.updateAnt(ant);
+      return { ant, output, messages, newTasks: [], pheromones: [], rateLimited: true };
+    }
+
+    nest.updateTaskStatus(task.id, success ? "done" : "failed", output, success ? undefined : stderr || output);
+
+    // 解析子任务和信息素
+    const newTasks = parseSubTasks(output);
+    const pheromones = extractPheromones(antId, antConfig.caste, task.id, output, task.files);
+    for (const p of pheromones) nest.dropPheromone(p);
+
+    return { ant, output, messages, newTasks, pheromones, rateLimited: false };
+  } finally {
+    try { fs.unlinkSync(tmpFile); } catch { /* ignore */ }
+    try { fs.rmdirSync(tmpDir); } catch { /* ignore */ }
+  }
+}