@saadnvd1/agent-os 0.3.715 → 0.3.728

package/lib/analyst/buildDigest.ts

@@ -0,0 +1,204 @@
+import type { ChatItem } from "../chat/events";
+import { lineDiff } from "../chat/diff";
+import { toolLine } from "../bus/condense";
+import { redact, untrusted } from "../orchestrator/untrusted";
+import { commandOf, isCheckCommand, signalLine, turnSignals } from "./signals";
+import type { DigestSignals } from "./types";
+
+// About 4k tokens for the whole digest.
+export const DIGEST_CAP = 16_000;
+const PROMPT_CAP = 2_000;
+const REPLY_CAP = 4_000;
+const OUTPUT_LINES = 40;
+const OUTPUT_CAP = 2_000;
+const DIFFS_CAP = 6_000;
+const DIFF_CONTEXT = 1;
+
+type Tool = Extract<ChatItem, { kind: "tool" }>;
+
+const clip = (text: string, cap: number) =>
+  text.length > cap
+    ? `${text.slice(0, cap)}\n[… ${text.length - cap} more chars]`
+    : text;
+
+const tail = (text: string) => {
+  const lines = text.trimEnd().split("\n");
+  const kept = lines.slice(-OUTPUT_LINES).join("\n");
+  const cut = kept.length > OUTPUT_CAP ? kept.slice(-OUTPUT_CAP) : kept;
+  return lines.length > OUTPUT_LINES || cut.length < kept.length
+    ? `[… earlier output left out]\n${cut}`
+    : cut;
+};
+
+// The changed lines and one line around each, as a unified diff body.
+export function hunks(before: string, after: string): string {
+  const lines = lineDiff(before, after);
+  const keep = new Set<number>();
+  lines.forEach((l, i) => {
+    if (l.op === " ") return;
+    for (let k = i - DIFF_CONTEXT; k <= i + DIFF_CONTEXT; k++) keep.add(k);
+  });
+  const out: string[] = [];
+  let last = -2;
+  lines.forEach((l, i) => {
+    if (!keep.has(i)) return;
+    if (i > last + 1 && out.length) out.push("…");
+    out.push(`${l.op}${l.text}`);
+    last = i;
+  });
+  return out.join("\n");
+}
+
+// Output worth the analyst's context: a check's, or a call that failed.
+const showsOutput = (t: Tool) => {
+  const command = commandOf(t);
+  return (
+    !!t.output &&
+    (t.status === "error" || (command !== null && isCheckCommand(command)))
+  );
+};
+
+interface Section {
+  prompt: string;
+  reply: string[];
+  tools: string[];
+  diffs: { path: string; body: string }[];
+}
+
+function sections(items: ChatItem[]): Section[] {
+  const out: Section[] = [];
+  let cur: Section | null = null;
+  const start = (prompt: string) => {
+    cur = { prompt, reply: [], tools: [], diffs: [] };
+    out.push(cur);
+  };
+  for (const item of items) {
+    if (item.kind === "user") {
+      // A message sent mid-turn is read inside the turn already running.
+      if (item.midTurn && cur) {
+        (cur as Section).reply.push(`[message during the turn] ${item.text}`);
+        continue;
+      }
+      start(item.text);
+      continue;
+    }
+    if (!cur) start("(earlier prompt, not in this batch)");
+    const c = cur as unknown as Section;
+    if (item.kind === "assistant" && item.text.trim()) c.reply.push(item.text);
+    else if (item.kind === "error") c.reply.push(`[error] ${item.message}`);
+    else if (item.kind === "plan") c.reply.push(`[plan] ${item.plan}`);
+    else if (item.kind === "approval") c.tools.push(toolLine(item));
+    else if (item.kind === "tool") {
+      c.tools.push(toolLine(item));
+      if (showsOutput(item))
+        c.tools.push(
+          tail(item.output!)
+            .split("\n")
+            .map((l) => `    ${l}`)
+            .join("\n")
+        );
+      if (item.diff && item.status !== "error")
+        c.diffs.push({
+          path: item.diff.path,
+          body: hunks(item.diff.before, item.diff.after),
+        });
+    } else if (item.kind === "turn_end" && item.interrupted)
+      c.reply.push("[turn stopped by the user]");
+    else if (item.kind === "turn_end" && item.ended)
+      c.reply.push(`[turn ended early: ${item.ended.notice}]`);
+  }
+  return out;
+}
+
+function renderDiffs(diffs: Section["diffs"]): string {
+  const parts: string[] = [];
+  let used = 0;
+  const left: string[] = [];
+  for (const d of diffs) {
+    const block = `--- ${d.path}\n${d.body}`;
+    if (used + block.length > DIFFS_CAP) {
+      left.push(d.path);
+      continue;
+    }
+    parts.push(block);
+    used += block.length;
+  }
+  if (left.length)
+    parts.push(`+${left.length} more files: ${[...new Set(left)].join(", ")}`);
+  return parts.join("\n");
+}
+
+function renderSection(s: Section, n: number, of: number): string {
+  const label = of > 1 ? `Turn ${n} of ${of}` : "Turn";
+  return [
+    `## ${label}: prompt`,
+    clip(s.prompt, PROMPT_CAP),
+    `## ${label}: reply`,
+    clip(s.reply.join("\n\n") || "(no text)", REPLY_CAP),
+    s.tools.length ? `## Tools\n${s.tools.join("\n")}` : "## Tools\n(none)",
+    s.diffs.length ? `## Changes\n${renderDiffs(s.diffs)}` : "",
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
+
+export interface Digest {
+  text: string;
+  signals: DigestSignals;
+  // What the chat shows in its place.
+  label: string;
+}
+
+/**
+ * The coding agent's turns as the analyst reads them: signals counted here
+ * first, then each turn's prompt, reply, tools, failing or check output and
+ * diffs, fenced as untrusted. Oldest turns are dropped first to fit the cap.
+ */
+export function buildDigest(
+  items: ChatItem[],
+  opts: { coderName: string; through: string; brief?: string }
+): Digest {
+  const signals = turnSignals(items);
+  const all = sections(items);
+  const head = [
+    opts.brief ?? "",
+    `The coding agent "${opts.coderName}" finished ${
+      signals.turns === 1 ? "a turn" : `${signals.turns} turns`
+    }. Review it and end with your agentos-review block.`,
+    `Signals (counted by AgentOS): ${redact(signalLine(signals))}`,
+  ]
+    .filter(Boolean)
+    .join("\n");
+  let kept = all;
+  let body = "";
+  let dropped = 0;
+  for (;;) {
+    body = kept
+      .map((s, i) => renderSection(s, i + 1, kept.length))
+      .join("\n\n");
+    if (dropped)
+      body = `[${dropped} earlier turn(s) left out to fit]\n\n${body}`;
+    const text = `${head}\n\n${untrusted(`coding agent ${opts.coderName}`, body)}`;
+    if (text.length <= DIGEST_CAP || kept.length <= 1)
+      return {
+        text:
+          text.length > DIGEST_CAP
+            ? clipDigest(head, opts.coderName, body)
+            : text,
+        signals,
+        label: `${opts.coderName} · ${
+          signals.turns === 1 ? "1 turn" : `${signals.turns} turns`
+        } to review`,
+      };
+    kept = kept.slice(1);
+    dropped++;
+  }
+}
+
+// A single turn still over the cap: its tail end is what matters most.
+function clipDigest(head: string, coderName: string, body: string): string {
+  const room = DIGEST_CAP - head.length - 200;
+  const cut =
+    body.length > room ? `[… cut to fit]\n${body.slice(-room)}` : body;
+  return `${head}\n\n${untrusted(`coding agent ${coderName}`, cut)}`;
+}

package/lib/analyst/createLink.ts

@@ -0,0 +1,98 @@
+import { db, type Session } from "../db";
+import { lastItems } from "../chat/store";
+import { launchSession } from "../sessions/launch";
+import { joinCrew } from "../sessions/crew";
+import { inheritGroup } from "../session-groups";
+import { isValidAgentType } from "../providers";
+import { archiveSession } from "../done/archive";
+import { ANALYST_BRIEF } from "./brief";
+import { pushDigest } from "./pushDigest";
+import { getLink, insertLink, liveLinkFor, linkOfAnalyst } from "./store";
+import { AnalystError, type AnalystLink, type CreateLinkInput } from "./types";
+
+const sessionRow = (id: string) =>
+  db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
+    Session | undefined;
+
+// Why a session can't have an analyst, or null when it can.
+export function coderRefusal(s: Session | undefined): string | null {
+  if (!s) return "Session not found";
+  if (s.archived_at) return `${s.name} is archived`;
+  if (s.role === "orchestrator") return "An orchestrator can't have an analyst";
+  if (s.view !== "chat")
+    return "Only a chat session can have an analyst: a terminal has no turns to review";
+  if ((s.host_id || "local") !== "local")
+    return "Only a session on this machine can have an analyst for now";
+  if (linkOfAnalyst(s.id)) return `${s.name} is an analyst itself`;
+  if (liveLinkFor(s.id)) return `${s.name} already has an analyst`;
+  return null;
+}
+
+const lastTurnEnd = (sessionId: string) =>
+  lastItems(sessionId, 1, "turn_end")[0]?.id ?? null;
+
+async function newCoder(
+  input: NonNullable<CreateLinkInput["newCoder"]>
+): Promise<Session> {
+  if (!isValidAgentType(input.agentType))
+    throw new AnalystError(`Unknown agent: ${input.agentType}`);
+  const { session } = await launchSession({
+    projectId: input.projectId,
+    agentType: input.agentType,
+    model: input.model ?? null,
+    prompt: input.prompt ?? null,
+    useWorktree: input.useWorktree,
+    view: "chat",
+  });
+  return sessionRow(session.id) ?? session;
+}
+
+/**
+ * Pairs an analyst with a coding chat: the analyst is a new chat in the
+ * coder's folder (no worktree of its own, so it reads exactly what the
+ * coder changed), in its crew and group. It reviews from the next turn on,
+ * or the last one now with `reviewLast`.
+ */
+export async function createLink(input: CreateLinkInput): Promise<AnalystLink> {
+  let coder: Session | undefined;
+  if (input.coderSessionId) {
+    coder = sessionRow(input.coderSessionId);
+    const refusal = coderRefusal(coder);
+    if (refusal) throw new AnalystError(refusal, coder ? 409 : 404);
+  } else coder = await newCoder(input.newCoder!);
+  if (!coder) throw new AnalystError("Session not found", 404);
+
+  const crewId = coder.crew_id || coder.id;
+  if (!coder.agent_role) joinCrew(coder.id, "developer", { crewId });
+  const { session: analyst } = await launchSession({
+    projectId: coder.project_id,
+    workingDirectory: coder.working_directory,
+    workspaceId: coder.workspace_id,
+    agentType: "claude",
+    model: input.analystModel ?? null,
+    agentRole: "analyst",
+    crewId,
+    parentSessionId: coder.id,
+    systemPrompt: ANALYST_BRIEF,
+    access: "ask",
+    useWorktree: false,
+    view: "chat",
+    name: `Analyst · ${coder.name}`,
+  });
+  inheritGroup(coder.id, analyst.id);
+
+  const review = !!input.reviewLast;
+  let link: AnalystLink;
+  try {
+    link = insertLink(
+      coder.id,
+      analyst.id,
+      review ? null : lastTurnEnd(coder.id)
+    );
+  } catch {
+    archiveSession(analyst.id);
+    throw new AnalystError(`${coder.name} already has an analyst`, 409);
+  }
+  if (review && lastTurnEnd(coder.id)) await pushDigest(link.id);
+  return getLink(link.id)!;
+}

package/lib/analyst/endLink.ts

@@ -0,0 +1,31 @@
+import { settleSession } from "../sidebar/shelf-state";
+import { endLinkRow, getLink, liveLinkFor, setPausedRow } from "./store";
+import { AnalystError, type AnalystLink } from "./types";
+
+// Unlinks: the rows stay. The analyst is settled too unless kept.
+export function endLink(
+  linkId: string,
+  opts: { endAnalyst?: boolean } = {}
+): AnalystLink {
+  const link = getLink(linkId);
+  if (!link) throw new AnalystError("Pairing not found", 404);
+  if (endLinkRow(link.id) && opts.endAnalyst !== false)
+    settleSession(link.analystSessionId);
+  return getLink(link.id)!;
+}
+
+// A session archived or done: its pairing ends. The analyst of a finished
+// coder is settled with it; a finished analyst leaves the coder alone.
+export function endLinkOf(sessionId: string): void {
+  const link = liveLinkFor(sessionId);
+  if (!link) return;
+  endLink(link.id, { endAnalyst: link.coderSessionId === sessionId });
+}
+
+export function setPaused(linkId: string, paused: boolean): AnalystLink {
+  const link = getLink(linkId);
+  if (!link) throw new AnalystError("Pairing not found", 404);
+  if (link.endedAt) throw new AnalystError("This pairing has ended", 409);
+  setPausedRow(link.id, paused);
+  return getLink(link.id)!;
+}

package/lib/analyst/forward.ts

@@ -0,0 +1,109 @@
+import { sendChat } from "../chat/runner";
+import { ASK_AGAIN } from "./brief";
+import { digestPrefix } from "./pushDigest";
+import {
+  decideRecommendation,
+  getLink,
+  getRecommendation,
+  markDigestPending,
+  reopenRecommendation,
+} from "./store";
+import { AnalystError, type AnalystLink, type Recommendation } from "./types";
+
+// A prompt into the coding agent's chat as the reader's decision, by id,
+// so a repeat is a no-op. It waits in the queue while a turn runs.
+export async function forwardToCoder(
+  coderSessionId: string,
+  input: { text: string; id: string; label: string; fromSessionId?: string }
+): Promise<void> {
+  await sendChat(coderSessionId, {
+    text: input.text,
+    id: input.id,
+    queue: true,
+    origin: {
+      kind: "decision",
+      label: input.label,
+      sessionId: input.fromSessionId,
+    },
+  });
+}
+
+function liveLink(linkId: string): AnalystLink {
+  const link = getLink(linkId);
+  if (!link) throw new AnalystError("Pairing not found", 404);
+  if (link.endedAt) throw new AnalystError("This pairing has ended", 409);
+  return link;
+}
+
+function cardOf(link: AnalystLink, recId: string): Recommendation {
+  const rec = getRecommendation(recId);
+  if (!rec || rec.linkId !== link.id)
+    throw new AnalystError("Recommendation not found", 404);
+  return rec;
+}
+
+export const sentItemId = (recId: string) => `user-analyst-rec-${recId}`;
+
+// Send to Coding Agent: the analyst's prompt, or the reader's edit of it.
+export async function sendRecommendation(
+  linkId: string,
+  recId: string,
+  edited?: string
+): Promise<Recommendation> {
+  const link = liveLink(linkId);
+  const rec = cardOf(link, recId);
+  const text = (edited ?? rec.prompt ?? "").trim();
+  if (!text) throw new AnalystError("There is no prompt to send", 400);
+  const id = sentItemId(rec.id);
+  const isEdit = edited !== undefined && edited.trim() !== rec.prompt?.trim();
+  // Claimed first, so two presses send once.
+  if (
+    !decideRecommendation(rec.id, "sent", { text, itemId: id, edited: isEdit })
+  )
+    throw new AnalystError(`This recommendation was already ${rec.state}`, 409);
+  try {
+    await forwardToCoder(link.coderSessionId, {
+      text,
+      id,
+      label: "Analyst",
+      fromSessionId: link.analystSessionId,
+    });
+  } catch (error) {
+    reopenRecommendation(rec.id);
+    throw error;
+  }
+  return getRecommendation(rec.id)!;
+}
+
+export function dismissRecommendation(
+  linkId: string,
+  recId: string
+): Recommendation {
+  const link = liveLink(linkId);
+  const rec = cardOf(link, recId);
+  if (!decideRecommendation(rec.id, "dismissed"))
+    throw new AnalystError(`This recommendation was already ${rec.state}`, 409);
+  return getRecommendation(rec.id)!;
+}
+
+// Ask again, on a card whose reply had no valid block: the analyst gets a
+// short correction, answered like the digest it replaces.
+export async function askAgain(linkId: string, recId: string): Promise<void> {
+  const link = liveLink(linkId);
+  const rec = cardOf(link, recId);
+  if (rec.state !== "invalid")
+    throw new AnalystError(
+      "Only a reply with no recommendation is asked again",
+      409
+    );
+  const id = `${digestPrefix(link.id)}again-${rec.id}`;
+  const through = rec.coderThrough ?? link.reviewedThrough;
+  if (through && link.digestSignals)
+    markDigestPending(link.id, id, through, link.digestSignals);
+  await sendChat(link.analystSessionId, {
+    text: ASK_AGAIN,
+    id,
+    queue: true,
+    origin: { kind: "system", label: "AgentOS" },
+  });
+}

package/lib/analyst/index.ts

@@ -0,0 +1,16 @@
+export * from "./types";
+export { createLink, coderRefusal } from "./createLink";
+export { endLink, endLinkOf, setPaused } from "./endLink";
+export { linkView, sessionLinkView } from "./linkView";
+export { pushDigest } from "./pushDigest";
+export {
+  askAgain,
+  dismissRecommendation,
+  forwardToCoder,
+  sendRecommendation,
+} from "./forward";
+export { analystTurnEndHook, resumeAnalystLinks } from "./resume";
+export { buildDigest } from "./buildDigest";
+export { turnSignals, signalLine, latestChecks } from "./signals";
+export { parseReview, REVIEW_FENCE } from "./parseReview";
+export { getLink, getLinkOrThrow } from "./store";

package/lib/analyst/linkView.ts

@@ -0,0 +1,38 @@
+import { db } from "../db";
+import { lastItems } from "../chat/store";
+import { getLink, listRecommendations, liveLinkFor } from "./store";
+import type { AnalystLinkView, PaneSession } from "./types";
+
+function pane(id: string): PaneSession {
+  const r = db
+    .prepare(
+      `SELECT id, name, agent_type, model FROM session_rows WHERE id = ?`
+    )
+    .get(id) as
+    | { id: string; name: string; agent_type: string; model: string | null }
+    | undefined;
+  return {
+    id,
+    name: r?.name ?? "Ended session",
+    agentType: r?.agent_type ?? "claude",
+    model: r?.model ?? null,
+  };
+}
+
+export function linkView(linkId: string): AnalystLinkView | null {
+  const link = getLink(linkId);
+  if (!link) return null;
+  return {
+    ...link,
+    coder: pane(link.coderSessionId),
+    analyst: pane(link.analystSessionId),
+    coderLastTurn: lastItems(link.coderSessionId, 1, "turn_end")[0]?.id ?? null,
+    recommendations: listRecommendations(link.id),
+  };
+}
+
+// The live pairing a session is in, as either side.
+export function sessionLinkView(sessionId: string): AnalystLinkView | null {
+  const link = liveLinkFor(sessionId);
+  return link ? linkView(link.id) : null;
+}

package/lib/analyst/onTurnEnd.ts

@@ -0,0 +1,119 @@
+import type { ChatItem } from "../chat/events";
+import { lastItems } from "../chat/store";
+import { parseReview, REVIEW_FENCE } from "./parseReview";
+import { digestPrefix, pushDigest } from "./pushDigest";
+import {
+  getLink,
+  insertRecommendation,
+  liveLinkFor,
+  recommendationFor,
+  settleDigest,
+} from "./store";
+import type { AnalystLink, Recommendation } from "./types";
+
+// Enough of the analyst's chat to hold one reply and the digest before it.
+const REPLY_ITEMS = 80;
+
+// The coding agent finished a turn: the analyst gets it, unless it's busy
+// with a digest (then it comes with the next one).
+export async function onCoderTurnEnd(sessionId: string): Promise<void> {
+  const link = liveLinkFor(sessionId);
+  if (link?.coderSessionId !== sessionId) return;
+  await pushDigest(link.id);
+}
+
+interface Reply {
+  // The message the turn answered.
+  prompt: Extract<ChatItem, { kind: "user" }> | null;
+  text: string;
+  // The item the review block is in (its card renders there), else the
+  // turn's end.
+  itemId: string;
+}
+
+function lastReply(sessionId: string, turnEndId: string): Reply | null {
+  const items = lastItems(sessionId, REPLY_ITEMS);
+  const end = items.findLastIndex((i) => i.id === turnEndId);
+  if (end < 0) return null;
+  const start = items.slice(0, end).findLastIndex((i) => i.kind === "user");
+  const turn = items.slice(start + 1, end);
+  const said = turn.filter(
+    (i): i is Extract<ChatItem, { kind: "assistant" }> => i.kind === "assistant"
+  );
+  const prompt = start >= 0 ? items[start] : null;
+  return {
+    prompt: prompt?.kind === "user" ? prompt : null,
+    text: said.map((i) => i.text).join("\n\n"),
+    itemId:
+      said.findLast((i) => i.text.includes(REVIEW_FENCE))?.id ??
+      said[said.length - 1]?.id ??
+      turnEndId,
+  };
+}
+
+// Turns the analyst's reply into a card: a recommendation when it carries a
+// valid block, an invalid one when it answered a digest without one.
+export function recordReply(
+  link: AnalystLink,
+  reply: Reply
+): Recommendation | null {
+  const digest =
+    !!reply.prompt?.id.startsWith(digestPrefix(link.id)) ||
+    reply.prompt?.id === link.pendingDigestId;
+  const parsed = parseReview(reply.text);
+  if (!parsed.ok && !digest) return null;
+  if (recommendationFor(link.id, reply.itemId)) return null;
+  const about = {
+    linkId: link.id,
+    analystItemId: reply.itemId,
+    coderThrough: link.pendingThrough ?? link.reviewedThrough,
+    signals: link.digestSignals,
+  };
+  return parsed.ok
+    ? insertRecommendation({
+        ...about,
+        verdict: parsed.review.verdict,
+        summary: parsed.review.summary,
+        issues: parsed.review.issues,
+        prompt: parsed.review.prompt ?? null,
+        state: "open",
+      })
+    : insertRecommendation({
+        ...about,
+        verdict: null,
+        summary: "",
+        issues: [],
+        prompt: null,
+        state: "invalid",
+        error: parsed.error,
+      });
+}
+
+// The analyst finished a turn: its review becomes a card, the digest it
+// answered counts as reviewed, and turns that ended meanwhile go next.
+export async function onAnalystTurnEnd(
+  sessionId: string,
+  turnEnd: Extract<ChatItem, { kind: "turn_end" }>
+): Promise<void> {
+  const link = liveLinkFor(sessionId);
+  if (link?.analystSessionId !== sessionId) return;
+  const reply = lastReply(sessionId, turnEnd.id);
+  if (!reply) return;
+  recordReply(link, reply);
+  const answered = reply.prompt?.id;
+  if (answered && answered === link.pendingDigestId)
+    settleDigest(link.id, answered);
+  if (getLink(link.id)?.pendingDigestId) return;
+  await pushDigest(link.id);
+}
+
+// What the chat hook calls for every finished turn.
+export async function onTurnEnd(
+  sessionId: string,
+  item: Extract<ChatItem, { kind: "turn_end" }>
+): Promise<void> {
+  const link = liveLinkFor(sessionId);
+  if (!link) return;
+  if (link.coderSessionId === sessionId) await onCoderTurnEnd(sessionId);
+  else await onAnalystTurnEnd(sessionId, item);
+}

package/lib/analyst/parseReview.ts

@@ -0,0 +1,41 @@
+import { reviewSchema, type Review } from "./types";
+
+export const REVIEW_FENCE = "agentos-review";
+
+const FENCE = new RegExp(
+  "(`{3,}|~{3,})[ \\t]*" + REVIEW_FENCE + "[^\\n]*\\n([\\s\\S]*?)\\n?\\1",
+  "g"
+);
+
+export type ParsedReview =
+  { ok: true; review: Review } | { ok: false; error: string };
+
+// The last agentos-review block in the analyst's reply, validated.
+export function parseReview(text: string): ParsedReview {
+  const blocks = [...text.matchAll(FENCE)];
+  if (!blocks.length)
+    return { ok: false, error: "The reply had no agentos-review block" };
+  return parseReviewJson(blocks[blocks.length - 1][2]);
+}
+
+export function parseReviewJson(raw: string): ParsedReview {
+  let json: unknown;
+  try {
+    json = JSON.parse(raw.trim());
+  } catch {
+    return { ok: false, error: "The agentos-review block isn't valid JSON" };
+  }
+  const got = reviewSchema.safeParse(json);
+  if (!got.success) {
+    const issue = got.error.issues[0];
+    return {
+      ok: false,
+      error: `The agentos-review block is invalid: ${issue.path.join(".") || "block"} ${issue.message}`,
+    };
+  }
+  const review = got.data;
+  return {
+    ok: true,
+    review: { ...review, prompt: review.prompt?.trim() || null },
+  };
+}