@saadnvd1/agent-os 0.3.533 → 0.3.534

package/lib/plans/pieces.ts

@@ -0,0 +1,366 @@
+/**
+ * The `## Pieces` block a plan ends with, and the deterministic check that
+ * decides how many pieces it really is. A plan is one piece unless it names
+ * one of four reasons for splitting, and these rules (not a model) enforce
+ * that: a piece without a standing reason is folded into the one before it.
+ */
+
+export const MAX_PIECES = 6;
+
+export type PieceReason = "a" | "b" | "c" | "d";
+
+export interface ProjectRef {
+  id: string;
+  name: string;
+  // Whether the project's agentos.json names a `deploy.deployed` file.
+  deploys: boolean;
+}
+
+export interface Piece {
+  position: number;
+  name: string;
+  slice: string;
+  project: ProjectRef;
+  afterPosition: number | null;
+  afterKind: "merged" | "deployed" | null;
+  reasons: PieceReason[];
+  owns: string[];
+}
+
+export interface Folded {
+  name: string;
+  into: number;
+  why: string;
+}
+
+export interface PiecesResult {
+  pieces: Piece[];
+  folded: Folded[];
+  warnings: string[];
+}
+
+interface Raw {
+  position: number;
+  name: string;
+  slice: string;
+  repo: string | null;
+  after: { position: number; kind: "merged" | "deployed" } | null;
+  reasons: PieceReason[];
+  owns: string[];
+}
+
+const HEADING = /^##\s+pieces\s*$/i;
+const ITEM = /^\s{0,3}(\d+)[.)]\s+(.*\S)\s*$/;
+const AFTER = /^\s*after:\s*(\d+)\s+is\s+(merged|deployed)\s*$/i;
+const WHY = /^\s*why split:\s*(.+?)\s*$/i;
+const OWNS = /^\s*owns:\s*(.+?)\s*$/i;
+
+function block(text: string): string[] | null {
+  const lines = text.split("\n");
+  let start = -1;
+  lines.forEach((l, i) => {
+    if (HEADING.test(l.trim())) start = i;
+  });
+  if (start < 0) return null;
+  const out: string[] = [];
+  for (const l of lines.slice(start + 1)) {
+    if (/^#{1,2}\s/.test(l)) break;
+    out.push(l);
+  }
+  return out;
+}
+
+function parseItem(position: number, rest: string): Raw {
+  let repo: string | null = null;
+  const withRepo = rest.match(/^(.*?)\s*\(repo:\s*([^)]+)\)\s*$/i);
+  if (withRepo) {
+    rest = withRepo[1];
+    repo = withRepo[2].trim();
+  }
+  const split = rest.indexOf(":");
+  const name = (split > 0 ? rest.slice(0, split) : rest).trim();
+  const slice = (split > 0 ? rest.slice(split + 1) : rest).trim();
+  return {
+    position,
+    name: name.slice(0, 80) || `Piece ${position}`,
+    slice: slice || name,
+    repo,
+    after: null,
+    reasons: [],
+    owns: [],
+  };
+}
+
+function parseBlock(lines: string[]): Raw[] | null {
+  const items: Raw[] = [];
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const item = line.match(ITEM);
+    if (item) {
+      items.push(parseItem(Number(item[1]), item[2]));
+      continue;
+    }
+    const current = items[items.length - 1];
+    if (!current) return null;
+    const after = line.match(AFTER);
+    const why = line.match(WHY);
+    const owns = line.match(OWNS);
+    if (after)
+      current.after = {
+        position: Number(after[1]),
+        kind: after[2].toLowerCase() as "merged" | "deployed",
+      };
+    else if (why)
+      current.reasons = [
+        ...new Set(
+          (why[1].toLowerCase().match(/\(([abcd])\)/g) ?? []).map(
+            (m) => m[1] as PieceReason
+          )
+        ),
+      ];
+    else if (owns)
+      current.owns = owns[1]
+        .split(/[,;]/)
+        .map((o) => o.trim().toLowerCase())
+        .filter(Boolean);
+    else return null;
+  }
+  if (!items.length || items.some((it, i) => it.position !== i + 1))
+    return null;
+  return items;
+}
+
+export interface CheckContext {
+  // The project the plan's task works in: a piece naming none gets this.
+  own: ProjectRef;
+  find: (name: string) => ProjectRef | null;
+}
+
+function one(text: string, ctx: CheckContext, warnings: string[]) {
+  return {
+    pieces: [
+      {
+        position: 1,
+        name: "Plan",
+        slice: text.trim().slice(0, 500),
+        project: ctx.own,
+        afterPosition: null,
+        afterKind: null,
+        reasons: [],
+        owns: [],
+      } satisfies Piece,
+    ],
+    folded: [] as Folded[],
+    warnings,
+  };
+}
+
+export function checkPieces(text: string, ctx: CheckContext): PiecesResult {
+  const lines = block(text);
+  if (!lines) return one("", ctx, []);
+  const raw = parseBlock(lines);
+  if (!raw)
+    return one("", ctx, [
+      "The Pieces block couldn't be read, so this is one piece.",
+    ]);
+  if (raw.length > MAX_PIECES)
+    return one("", ctx, [
+      `${raw.length} pieces is past the limit of ${MAX_PIECES}; built as one piece.`,
+    ]);
+
+  const warnings: string[] = [];
+  const projects = raw.map((r) => {
+    if (!r.repo) return ctx.own;
+    const found = ctx.find(r.repo);
+    if (!found)
+      warnings.push(`"${r.name}": no project named ${r.repo}; using this one.`);
+    return found ?? ctx.own;
+  });
+
+  // Where each original piece ended up, for `after:` lines that pointed at a
+  // piece that was folded.
+  const landed = new Map<number, number>();
+  const pieces: Piece[] = [];
+  const folded: Folded[] = [];
+
+  raw.forEach((r, i) => {
+    const project = projects[i];
+    const fold = (why: string) => {
+      const into = pieces[pieces.length - 1];
+      into.slice = `${into.slice}\n${r.name}: ${r.slice}`;
+      into.owns = [...new Set([...into.owns, ...r.owns])];
+      landed.set(r.position, into.position);
+      folded.push({ name: r.name, into: into.position, why });
+    };
+    const keep = (p: Omit<Piece, "position">) => {
+      const position = pieces.length + 1;
+      pieces.push({ ...p, position });
+      landed.set(r.position, position);
+    };
+
+    if (i === 0) {
+      keep({
+        name: r.name,
+        slice: r.slice,
+        project,
+        afterPosition: null,
+        afterKind: null,
+        reasons: [],
+        owns: r.owns,
+      });
+      return;
+    }
+
+    let reasons = r.reasons;
+    if (!reasons.length) return fold("no reason for a separate piece");
+
+    if (reasons.includes("a")) {
+      const others = projects.filter((_, j) => j !== i);
+      if (others.some((p) => p.id === project.id)) {
+        reasons = reasons.filter((x) => x !== "a");
+        warnings.push(
+          `"${r.name}" claimed (a) but shares a repo with another piece.`
+        );
+      }
+    }
+
+    let afterPosition: number | null = null;
+    let afterKind = r.after?.kind ?? null;
+    if (r.after) {
+      const target = landed.get(r.after.position);
+      if (target === undefined || r.after.position >= r.position) {
+        warnings.push(`"${r.name}": after: ${r.after.position} isn't earlier.`);
+        afterKind = null;
+      } else {
+        afterPosition = target;
+      }
+    }
+
+    if (reasons.includes("b")) {
+      const dep = afterPosition ? pieces[afterPosition - 1] : null;
+      if (afterKind !== "deployed" || !dep) {
+        reasons = reasons.filter((x) => x !== "b");
+      } else if (!dep.project.deploys) {
+        reasons = reasons.filter((x) => x !== "b");
+        afterKind = "merged";
+        warnings.push(
+          `"${r.name}" waits on a deploy that ${dep.project.name} can't check; it waits for the merge instead.`
+        );
+      }
+    } else if (afterKind === "deployed") {
+      const dep = afterPosition ? pieces[afterPosition - 1] : null;
+      if (!dep?.project.deploys) afterKind = "merged";
+    }
+
+    if (!reasons.length) return fold("its reason didn't hold");
+
+    keep({
+      name: r.name,
+      slice: r.slice,
+      project,
+      afterPosition,
+      afterKind: afterPosition ? (afterKind ?? "merged") : null,
+      reasons,
+      owns: r.owns,
+    });
+  });
+
+  const seen = new Map<string, number>();
+  for (const p of pieces)
+    for (const o of p.owns) {
+      const first = seen.get(o);
+      if (first !== undefined && first !== p.position)
+        warnings.push(`"${o}" is owned by pieces ${first} and ${p.position}.`);
+      else seen.set(o, p.position);
+    }
+
+  return { pieces, folded, warnings };
+}
+
+export const PIECES_PROMPT = `At the end of the plan, add a \`## Pieces\` block. The default is exactly one piece, which is what almost every task is, and one piece needs no more than:
+
+## Pieces
+1. <name>: <one-line slice>  (repo: <project>)
+
+Add another piece only when one of these holds, and say which on a \`why split:\` line:
+(a) it spans repositories (a task works in one repo);
+(b) one part must be live (merged and deployed) before the other can merge;
+(c) one part needs the user mid-way (signing, a credential, a product call) and the rest doesn't;
+(d) one part must be revertible on its own: a migration that rewrites or deletes existing rows, or an auth or security change bundled with unrelated work. An additive migration doesn't count.
+Diff size is never a reason. A later piece looks like:
+2. <name>: <one-line slice>  (repo: <project>)
+   after: 1 is merged   (or: 1 is deployed)
+   why split: (a) + (b)
+   owns: migration 81
+A shared resource (a migration id, a new table, a config key) goes on exactly one piece's \`owns:\` line. A piece with no valid reason is folded into the one before it.`;
+
+// Shown to a piece's agent in place of the whole plan.
+export function pieceBrief(
+  total: number,
+  piece: Pick<Piece, "position" | "name" | "slice" | "owns">,
+  planPath: string,
+  before: string[] = []
+): string {
+  const owns = piece.owns.length
+    ? `\nThis piece owns: ${piece.owns.join(", ")}. No other piece touches it.`
+    : "";
+  const earlier = before.length
+    ? `\nPieces before you: ${before.join("; ")}.`
+    : "";
+  return `Build piece ${piece.position} of ${total} only, "${piece.name}": ${piece.slice}${owns}${earlier}\nThe rest of the plan is other pieces' work; don't start it. Full plan: ${planPath}`;
+}
+
+export interface PlanEdits {
+  // Positions to fold into the piece before them, and to leave out.
+  merge?: number[];
+  drop?: number[];
+}
+
+export function parseEdits(raw: string | null | undefined): PlanEdits {
+  try {
+    const o = JSON.parse(raw ?? "{}") as PlanEdits;
+    const ints = (v: unknown) =>
+      Array.isArray(v) ? v.filter((n) => Number.isInteger(n)) : [];
+    return { merge: ints(o.merge), drop: ints(o.drop) };
+  } catch {
+    return {};
+  }
+}
+
+// Saad's edits to the pieces before approving: a merged piece joins the one
+// before it, a dropped one is left out (and listed, so nothing vanishes).
+// Piece 1 can't be dropped or merged.
+export function applyEdits(
+  result: PiecesResult,
+  edits: PlanEdits
+): { pieces: Piece[]; notBuilding: string[] } {
+  const drop = new Set(edits.drop ?? []);
+  const merge = new Set(edits.merge ?? []);
+  const notBuilding: string[] = [];
+  const kept: Piece[] = [];
+  const landed = new Map<number, number>();
+  for (const p of result.pieces) {
+    const before = kept[kept.length - 1];
+    if (p.position > 1 && drop.has(p.position)) {
+      notBuilding.push(`${p.name}: ${p.slice}`);
+      continue;
+    }
+    if (p.position > 1 && merge.has(p.position) && before) {
+      before.slice = `${before.slice}\n${p.name}: ${p.slice}`;
+      before.owns = [...new Set([...before.owns, ...p.owns])];
+      landed.set(p.position, before.position);
+      continue;
+    }
+    const position = kept.length + 1;
+    landed.set(p.position, position);
+    const after =
+      p.afterPosition === null ? undefined : landed.get(p.afterPosition);
+    kept.push({
+      ...p,
+      position,
+      afterPosition: after && after < position ? after : null,
+      afterKind: after && after < position ? p.afterKind : null,
+    });
+  }
+  return { pieces: kept, notBuilding };
+}

package/lib/plans/release.ts

@@ -0,0 +1,323 @@
+// Pieces of a feature after the plan is approved: noticing which merged,
+// starting the ones whose dependency is met, and closing the feature.
+
+import { randomUUID } from "crypto";
+import { db, type Session } from "../db";
+import { getProject } from "../projects";
+import { loadProjectConfig } from "../project-config";
+import { createTask } from "../tasks";
+import { startOrQueue } from "../tasks/queue";
+import { braked, BrakeRefused } from "../orchestrator/brakes";
+import { queueEvent } from "../orchestrator/events";
+import { amendBrief } from "../orchestrator/amendments";
+import { usageRows } from "../session-logs/gather";
+import { pieceBrief } from "./pieces";
+import {
+  getFeature,
+  planPathOf,
+  piecesOf,
+  type Feature,
+  type FeaturePiece,
+} from "./features";
+
+export type DependencyState = "ok" | "pending" | "failed";
+
+export interface ReleaseDeps {
+  // Whether a merged piece's change is live (for `after: N is deployed`).
+  deployed: (dep: FeaturePiece, session: Session) => Promise<DependencyState>;
+  start: (
+    feature: Feature,
+    piece: FeaturePiece,
+    prompt: string,
+    sessionId: string
+  ) => Promise<string>;
+  pushFeatureMerged: (feature: Feature) => void;
+}
+
+const sessionOf = (id: string | null) =>
+  id
+    ? (db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+        | Session
+        | undefined)
+    : undefined;
+
+const setPiece = (id: number, status: string, note: string | null = null) =>
+  db
+    .prepare(`UPDATE feature_pieces SET status = ?, note = ? WHERE id = ?`)
+    .run(status, note, id);
+
+// What a piece's task did: merged, or ended some other way.
+function syncPieces(pieces: FeaturePiece[]): void {
+  for (const p of pieces) {
+    if (p.status !== "building") continue;
+    const s = sessionOf(p.session_id);
+    if (!s) {
+      // Still in the queue, or the queue gave up on it.
+      const q = db
+        .prepare(`SELECT status, error FROM task_queue WHERE id = ?`)
+        .get(p.session_id) as
+        | { status: string; error: string | null }
+        | undefined;
+      if (q?.status === "removed")
+        setPiece(p.id, "dropped", "removed from the queue");
+      else if (q?.status === "failed")
+        setPiece(p.id, "blocked", q.error ?? "it couldn't start");
+      else if (!q) setPiece(p.id, "blocked", "its task is gone");
+      continue;
+    }
+    if (s.task_status === "merged") setPiece(p.id, "merged");
+    else if (s.task_status === "dropped" || s.task_status === "done")
+      setPiece(p.id, "dropped", `its task was ${s.task_status}`);
+  }
+}
+
+export const realDeps: ReleaseDeps = {
+  // Only a confirmed deploy releases the next piece: anything that can't be
+  // checked blocks it (a missing project or PR) or keeps it waiting.
+  deployed: async (dep, session) => {
+    const project = getProject(dep.project_id);
+    if (!project || !session.pr_number || !session.merged_at) return "failed";
+    const repo = project.working_directory.replace(
+      /^~/,
+      process.env.HOME ?? "~"
+    );
+    const config = loadProjectConfig(repo).config.deploy;
+    const { checkDeploy } = await import("../away/deploy");
+    const { mergeCommit } = await import("../away/run");
+    const verdict = await checkDeploy({
+      repo,
+      config,
+      mergeSha: config ? await mergeCommit(repo, session.pr_number) : null,
+      mergedAt: Date.parse(`${session.merged_at}Z`),
+      now: Date.now(),
+    });
+    return verdict.state === "ok"
+      ? "ok"
+      : verdict.state === "failed"
+        ? "failed"
+        : "pending";
+  },
+  start: async (feature, piece, prompt, sessionId) => {
+    const plan = sessionOf(feature.plan_session_id);
+    const req = {
+      projectId: piece.project_id,
+      prompt,
+      name: `${feature.name} · ${piece.name}`,
+      plan: false,
+      planReason: "feature piece",
+      // A retry under the same id clears what a failed attempt left behind.
+      reclaim: true,
+      startedBy: plan?.started_by ?? null,
+      originWorkspaceId: feature.workspace_id,
+    };
+    // A queued task keeps its queue id as its session id once it starts.
+    const out = await startOrQueue(req, () =>
+      braked(
+        feature.workspace_id,
+        "task",
+        () => createTask({ ...req, id: sessionId }),
+        (s) => (s as { id?: string }).id ?? null,
+        { spendApproval: false }
+      )
+    );
+    return "queued" in out ? out.queued.id : sessionId;
+  },
+  pushFeatureMerged: (feature) =>
+    void import("../notify/push/events").then((m) =>
+      m.pushFeatureMerged(feature.id, feature.name)
+    ),
+};
+
+function say(feature: Feature, key: string, line: string): void {
+  queueEvent(
+    feature.workspace_id,
+    `feature:${key}`,
+    feature.plan_session_id,
+    line
+  );
+}
+
+function beforeLines(all: FeaturePiece[], upTo: number): string[] {
+  return all
+    .filter((p) => p.position < upTo && p.status === "merged")
+    .map((p) => {
+      const pr = sessionOf(p.session_id)?.pr_number;
+      return `${p.position} ${p.name} merged${pr ? ` as #${pr}` : ""}`;
+    });
+}
+
+async function releaseOne(
+  feature: Feature,
+  all: FeaturePiece[],
+  piece: FeaturePiece,
+  deps: ReleaseDeps
+): Promise<void> {
+  const dep = piece.after_position
+    ? all.find((p) => p.position === piece.after_position)
+    : undefined;
+  if (dep) {
+    if (dep.status === "dropped" || dep.status === "blocked") {
+      const note = `waits on ${dep.position} ${dep.name}, which was ${dep.status === "dropped" ? "dropped" : "blocked"}`;
+      setPiece(piece.id, "blocked", note);
+      say(
+        feature,
+        `blocked-${piece.id}`,
+        `Feature "${feature.name}": piece ${piece.position} ${piece.name} ${note}. Release it anyway or drop it.`
+      );
+      return;
+    }
+    if (dep.status !== "merged") return;
+    if (piece.after_kind === "deployed") {
+      const session = sessionOf(dep.session_id);
+      const state = session ? await deps.deployed(dep, session) : "failed";
+      if (state === "pending") return;
+      if (state === "failed") {
+        const note = `${dep.position} ${dep.name} merged but its deploy failed or couldn't be confirmed`;
+        setPiece(piece.id, "blocked", note);
+        say(
+          feature,
+          `blocked-${piece.id}`,
+          `Feature "${feature.name}": piece ${piece.position} ${piece.name} is held: ${note}.`
+        );
+        return;
+      }
+    }
+  }
+  const claimed = db
+    .prepare(
+      `UPDATE feature_pieces SET status = 'building', session_id = ?, note = NULL
+       WHERE id = ? AND status = 'waiting'`
+    )
+    .run((piece.session_id ??= randomUUID()), piece.id).changes;
+  if (!claimed) return;
+  const prompt = `[Feature "${feature.name}", piece ${piece.position} of ${all.length}, started by AgentOS from an approved plan]\n${pieceBrief(all.length, { position: piece.position, name: piece.name, slice: piece.slice, owns: piece.owns ? piece.owns.split(", ") : [] }, planPathOf(feature.id), beforeLines(all, piece.position))}`;
+  try {
+    const id = await deps.start(feature, piece, prompt, piece.session_id);
+    if (id !== piece.session_id)
+      db.prepare(`UPDATE feature_pieces SET session_id = ? WHERE id = ?`).run(
+        id,
+        piece.id
+      );
+  } catch (error) {
+    if (error instanceof BrakeRefused) {
+      // Held for the next sweep: nothing was made.
+      db.prepare(
+        `UPDATE feature_pieces SET status = 'waiting', session_id = NULL WHERE id = ?`
+      ).run(piece.id);
+      return;
+    }
+    // Anything else would fail the same way every sweep: hold it, say so
+    // once. Its id is kept, so "Release anyway" starts it by the same id
+    // and clears what this attempt left.
+    const why = error instanceof Error ? error.message : String(error);
+    setPiece(piece.id, "blocked", `it couldn't start: ${why}`.slice(0, 300));
+    say(
+      feature,
+      `start-${piece.id}`,
+      `Feature "${feature.name}": piece ${piece.position} ${piece.name} couldn't start: ${why}. Release it anyway to try again, or drop it.`
+    );
+  }
+}
+
+function close(feature: Feature, all: FeaturePiece[], deps: ReleaseDeps): void {
+  const live = all.filter((p) => p.status !== "dropped");
+  if (!live.length) {
+    db.prepare(`UPDATE features SET status = 'dropped' WHERE id = ?`).run(
+      feature.id
+    );
+    return;
+  }
+  if (live.some((p) => p.status !== "merged")) return;
+  const sessions = live
+    .map((p) => sessionOf(p.session_id))
+    .filter(Boolean) as Session[];
+  const cost = sessions.reduce(
+    (n, s) => n + usageRows(s.id).reduce((m, r) => m + r.costUsd, 0),
+    0
+  );
+  const ended = Math.max(
+    ...sessions.map((s) => (s.merged_at ? Date.parse(`${s.merged_at}Z`) : 0))
+  );
+  const started = Date.parse(`${feature.created_at}Z`);
+  const claimed = db
+    .prepare(
+      `UPDATE features SET status = 'done', done_at = datetime('now'), cost_usd = ?, duration_ms = ?
+       WHERE id = ? AND status = 'building'`
+    )
+    .run(cost, ended > started ? ended - started : null, feature.id).changes;
+  if (!claimed) return;
+  say(
+    feature,
+    `done-${feature.id}`,
+    `Feature "${feature.name}" is merged: ${live.length} ${live.length === 1 ? "PR" : "PRs"}.`
+  );
+  deps.pushFeatureMerged(feature);
+}
+
+export async function releasePieces(
+  deps: ReleaseDeps = realDeps
+): Promise<void> {
+  const features = db
+    .prepare(`SELECT * FROM features WHERE status = 'building'`)
+    .all() as Feature[];
+  for (const feature of features) {
+    syncPieces(piecesOf(feature.id));
+    const all = piecesOf(feature.id);
+    for (const piece of all.filter((p) => p.status === "waiting"))
+      await releaseOne(feature, piecesOf(feature.id), piece, deps).catch((e) =>
+        console.error(`[features] piece ${piece.id}:`, e)
+      );
+    close(feature, piecesOf(feature.id), deps);
+  }
+}
+
+// "Release anyway": a blocked piece stops waiting on what held it.
+export function releaseAnyway(pieceId: number): boolean {
+  return (
+    db
+      .prepare(
+        `UPDATE feature_pieces SET status = 'waiting', after_position = NULL,
+           after_kind = NULL, note = NULL WHERE id = ? AND status = 'blocked'`
+      )
+      .run(pieceId).changes > 0
+  );
+}
+
+// The orchestrator's second look at a plan while pieces still wait: fold a
+// waiting piece into the one before it, or leave it out.
+export function editWaiting(
+  featureId: string,
+  edits: { merge?: number[]; drop?: number[] }
+): string[] {
+  const done: string[] = [];
+  const all = piecesOf(featureId);
+  const feature = getFeature(featureId);
+  for (const n of [...(edits.drop ?? []), ...(edits.merge ?? [])]) {
+    const piece = all.find((p) => p.position === n);
+    if (!piece || piece.status !== "waiting" || n < 2 || !feature) continue;
+    if (!(edits.merge ?? []).includes(n)) {
+      // Pieces that wait on it are then held, not freed.
+      setPiece(piece.id, "dropped", "dropped");
+      done.push(`${n} dropped`);
+      continue;
+    }
+    const into = all
+      .filter((p) => p.position < n && p.status !== "dropped")
+      .pop();
+    if (!into) continue;
+    const slice = `${piece.name}: ${piece.slice}`;
+    if (into.status === "waiting")
+      db.prepare(
+        `UPDATE feature_pieces SET slice = slice || ? WHERE id = ?`
+      ).run(`\n${slice}`, into.id);
+    else if (into.status === "building" && into.session_id)
+      amendBrief(feature.workspace_id, into.session_id, slice);
+    else continue;
+    setPiece(piece.id, "dropped", `merged into ${into.position}`);
+    db.prepare(
+      `UPDATE feature_pieces SET after_position = ? WHERE feature_id = ? AND after_position = ?`
+    ).run(into.position, featureId, n);
+    done.push(`${n} merged into ${into.position}`);
+  }
+  return done;
+}