@saadnvd1/agent-os 0.3.700 → 0.3.723

package/README.md

@@ -28,9 +28,11 @@ and check on all of it from your phone.
 - **Project config.** `agentos.json` gives each session its own ports, environment, files and a private Postgres copy. [More](docs/reference/project-config.md)
 - **Schedules and recipes.** Start work on a timer, or save a job that comes up again. [More](docs/guides/schedules.md)
 - **Plans in pieces and stacks.** A plan splits into several PRs only for a real reason; a board can run as stacked PRs. [More](docs/guides/tasks.md#plans-in-pieces)
+- **Export a session for AI.** A whole chat or a range of its turns as Markdown, JSON or HTML, with a compact mode, the same masking as Share, a size and token estimate, and every cut labelled. [More](docs/guides/export.md)
 - **Machine load and status.** A load gauge, each session's share of CPU and memory, and Needs you, Working, In review and Done as it changes. [More](docs/guides/sessions.md)
 - **A health watcher.** Zero-token checks on the orchestrator's tick catch a red machine load, a held queue, a quiet background job, a restart loop, slow CI, a PR armed for hours and a piece started twice. Each trip wakes one short, tool-less Sonnet call that judges it and posts one line to the orchestrator; only a thing you alone can clear reaches your phone. Settings → Health lists what is open, the history, the notes on what normal looks like and the thresholds. Report only: it never acts. [More](docs/reference/health.md)
 - **Workspaces.** Group projects, finish work with Done, and get a log of every merged task. [More](docs/reference/workspaces.md)
+- **Session groups.** Named shelves inside a workspace, under Pinned, for sessions that belong together; a group stays put while its sessions change state. [More](docs/guides/sessions.md#groups)
 - **LumifyHub (optional).** Boards, cards and docs for a workspace, if you want them. [More](docs/lumifyhub.md)
 - **No approvals mode.** One switch in Settings that approves every ask, lets brakes and plan-only tasks through, and starts every agent with its permission prompts off; each approval it makes is logged. Off by default. [More](docs/reference/orchestrator.md#no-approvals-mode)
 - **Experiments.** Settings → Experiments lists features still being tried, each off until you turn it on, with what it has cost and how often its suggestions were taken. The first is Learning cards: when a session ends it can offer to save the work as a recipe or keep a lesson where it belongs. [More](docs/decisions/2026-10-13-experiments.md)

package/app/api/agent-roles/route.test.ts

@@ -0,0 +1,67 @@
+import { NextRequest } from "next/server";
+import { beforeEach, describe, expect, it } from "vitest";
+import { db } from "@/lib/db";
+import { GET, PUT } from "./route";
+import { TRUST_HEADER } from "@/lib/security/auth";
+
+const url = "http://localhost/api/agent-roles";
+const put = (body: unknown, trusted = true) =>
+  PUT(
+    new NextRequest(url, {
+      method: "PUT",
+      body: JSON.stringify(body),
+      headers: trusted ? { [TRUST_HEADER]: "loopback" } : {},
+    })
+  );
+const get = (q = "") => GET(new NextRequest(`${url}${q}`));
+
+beforeEach(() => {
+  db.prepare(`DELETE FROM settings WHERE key LIKE 'models%'`).run();
+});
+
+describe("/api/agent-roles", () => {
+  it("lists the four roles with the model in force", async () => {
+    const { roles } = await (await get()).json();
+    expect(roles.map((r: { id: string }) => r.id)).toEqual([
+      "developer",
+      "analyst",
+      "reviewer",
+      "supervisor",
+    ]);
+    expect(roles[0].binding).toMatchObject({ source: "default" });
+  });
+
+  it("saves a role and shows it back", async () => {
+    const res = await put({
+      scope: "settings",
+      roles: { analyze: "anthropic/claude-sonnet-5-5" },
+    });
+    expect(res.status).toBe(200);
+    const { roles } = await res.json();
+    expect(roles.find((r: { id: string }) => r.id === "analyst")).toMatchObject(
+      {
+        value: "anthropic/claude-sonnet-5-5",
+        binding: { source: "settings" },
+      }
+    );
+  });
+
+  it("refuses a request that isn't from this machine or the tailnet", async () => {
+    expect((await put({ scope: "settings", roles: {} }, false)).status).toBe(
+      403
+    );
+  });
+
+  it("refuses a Pi model for a role that can't run it", async () => {
+    const res = await put({
+      scope: "settings",
+      roles: { orchestrator: "pi/local/qwen3-27b" },
+    });
+    expect(res.status).toBe(400);
+  });
+
+  it("404s an unknown project and 400s a bad scope", async () => {
+    expect((await get("?scope=project&id=nope")).status).toBe(404);
+    expect((await get("?scope=galaxy")).status).toBe(400);
+  });
+});

package/app/api/agent-roles/route.ts

@@ -0,0 +1,61 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { agentRolesView, saveAgentRoles } from "@/lib/models/agent-roles-view";
+import { roleMapSchema } from "@/lib/models/config";
+import { getProject } from "@/lib/projects";
+import { getWorkspace } from "@/lib/workspaces";
+import { requireLocalTrust } from "@/lib/security/route-guard";
+
+const scopeQuery = z.object({
+  scope: z.enum(["settings", "workspace", "project"]).default("settings"),
+  id: z.string().min(1).optional(),
+});
+
+function known({ scope, id }: z.infer<typeof scopeQuery>): string | null {
+  if (scope === "settings") return null;
+  if (!id) return `${scope} needs an id`;
+  if (scope === "workspace" && !getWorkspace(id)) return "Workspace not found";
+  if (scope === "project" && !getProject(id)) return "Project not found";
+  return null;
+}
+
+// GET /api/agent-roles?scope=settings|workspace|project&id= - the four
+// agent roles and the internal ones: what's saved at the scope, the model in
+// force and where it came from, and the model's locality and availability.
+export async function GET(request: NextRequest) {
+  const q = scopeQuery.safeParse(
+    Object.fromEntries(request.nextUrl.searchParams)
+  );
+  if (!q.success)
+    return NextResponse.json({ error: "Bad scope" }, { status: 400 });
+  const missing = known(q.data);
+  if (missing) return NextResponse.json({ error: missing }, { status: 404 });
+  return NextResponse.json(agentRolesView(q.data));
+}
+
+const body = scopeQuery.extend({
+  roles: roleMapSchema,
+  fallbacks: roleMapSchema.optional(),
+});
+
+// PUT /api/agent-roles {scope, id?, roles, fallbacks?} - replaces the roles
+// saved at the scope. Only from this machine or the tailnet, like Settings.
+export async function PUT(request: NextRequest) {
+  const refused = requireLocalTrust(request);
+  if (refused) return refused;
+  try {
+    const b = body.parse(await request.json());
+    const missing = known(b);
+    if (missing) return NextResponse.json({ error: missing }, { status: 404 });
+    saveAgentRoles(b, b.roles, b.fallbacks);
+    return NextResponse.json(agentRolesView(b));
+  } catch (error) {
+    const message =
+      error instanceof z.ZodError
+        ? error.issues.map((i) => i.message).join("; ")
+        : error instanceof Error
+          ? error.message
+          : String(error);
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}

package/app/api/analyst/[id]/recommendations/[recId]/again/route.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { askAgain } from "@/lib/analyst";
+import { analystRoute } from "@/lib/analyst/route";
+
+type Ctx = { params: Promise<{ id: string; recId: string }> };
+
+// POST /api/analyst/:id/recommendations/:recId/again - Ask again, for a
+// reply that carried no valid recommendation.
+export async function POST(request: Request, { params }: Ctx) {
+  const { id, recId } = await params;
+  return analystRoute(request, z.object({}), async () => {
+    await askAgain(id, recId);
+    return { ok: true };
+  });
+}

package/app/api/analyst/[id]/recommendations/[recId]/dismiss/route.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import { dismissRecommendation } from "@/lib/analyst";
+import { analystRoute } from "@/lib/analyst/route";
+
+type Ctx = { params: Promise<{ id: string; recId: string }> };
+
+// POST /api/analyst/:id/recommendations/:recId/dismiss - 409 once decided.
+export async function POST(request: Request, { params }: Ctx) {
+  const { id, recId } = await params;
+  return analystRoute(request, z.object({}), () => ({
+    recommendation: dismissRecommendation(id, recId),
+  }));
+}

package/app/api/analyst/[id]/recommendations/[recId]/send/route.ts

@@ -0,0 +1,13 @@
+import { sendRecommendation, sendSchema } from "@/lib/analyst";
+import { analystRoute } from "@/lib/analyst/route";
+
+type Ctx = { params: Promise<{ id: string; recId: string }> };
+
+// POST /api/analyst/:id/recommendations/:recId/send { text? } - Send to
+// Coding Agent, edited when text is given. 409 once decided.
+export async function POST(request: Request, { params }: Ctx) {
+  const { id, recId } = await params;
+  return analystRoute(request, sendSchema, async (b) => ({
+    recommendation: await sendRecommendation(id, recId, b.text),
+  }));
+}

package/app/api/analyst/[id]/review/route.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { AnalystError, getLinkOrThrow, pushDigest } from "@/lib/analyst";
+import { analystRoute } from "@/lib/analyst/route";
+
+type Ctx = { params: Promise<{ id: string }> };
+
+// POST /api/analyst/:id/review - Review now: the turns since the last
+// review, or the last turn again.
+export async function POST(request: Request, { params }: Ctx) {
+  const { id } = await params;
+  return analystRoute(request, z.object({}), async () => {
+    const link = getLinkOrThrow(id);
+    if (link.endedAt) throw new AnalystError("This pairing has ended", 409);
+    const result = await pushDigest(id, { force: true });
+    if (result === "nothing")
+      throw new AnalystError(
+        "The coding agent hasn't finished a turn yet",
+        409
+      );
+    return { result };
+  });
+}

package/app/api/analyst/[id]/route.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import {
+  AnalystError,
+  endLink,
+  linkView,
+  patchLinkSchema,
+  setPaused,
+} from "@/lib/analyst";
+import { analystRoute, run } from "@/lib/analyst/route";
+
+type Ctx = { params: Promise<{ id: string }> };
+
+const view = (id: string) => {
+  const link = linkView(id);
+  if (!link) throw new AnalystError("Pairing not found", 404);
+  return { link };
+};
+
+// GET /api/analyst/:id - the pairing, both sessions and its latest cards.
+export async function GET(_request: Request, { params }: Ctx) {
+  const { id } = await params;
+  return run(() => view(id));
+}
+
+// PATCH /api/analyst/:id { paused } - stop or resume sending turns.
+export async function PATCH(request: Request, { params }: Ctx) {
+  const { id } = await params;
+  return analystRoute(request, patchLinkSchema, (b) => {
+    setPaused(id, b.paused);
+    return view(id);
+  });
+}
+
+const unlink = z.object({ endAnalyst: z.boolean().optional() });
+
+// DELETE /api/analyst/:id { endAnalyst? } - unlink; the analyst is settled
+// unless endAnalyst is false. History is kept.
+export async function DELETE(request: Request, { params }: Ctx) {
+  const { id } = await params;
+  return analystRoute(request, unlink, (b) => {
+    endLink(id, b);
+    return view(id);
+  });
+}

package/app/api/analyst/route.ts

@@ -0,0 +1,10 @@
+import { createLink, createLinkSchema, linkView } from "@/lib/analyst";
+import { analystRoute } from "@/lib/analyst/route";
+
+// POST /api/analyst { coderSessionId | newCoder, analystModel?, reviewLast? }
+// - pairs an analyst chat with a coding chat (a new one with newCoder).
+export async function POST(request: Request) {
+  return analystRoute(request, createLinkSchema, async (b) => ({
+    link: linkView((await createLink(b)).id),
+  }));
+}

package/app/api/bus/groups/route.ts

@@ -0,0 +1,44 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { groupCommand } from "@/lib/session-groups/cli";
+import { GROUP_STATUS, GroupError } from "@/lib/session-groups";
+
+const refs = z.array(z.string().min(1)).min(1);
+const body = z.object({
+  from: z.string().min(1, "aos group runs from inside an AgentOS session"),
+  command: z.discriminatedUnion("action", [
+    z.object({ action: z.literal("list") }),
+    z.object({ action: z.literal("new"), name: z.string() }),
+    z.object({
+      action: z.literal("rename"),
+      group: z.string(),
+      name: z.string(),
+    }),
+    z.object({
+      action: z.literal("add"),
+      group: z.string(),
+      sessions: refs,
+    }),
+    z.object({ action: z.literal("rm"), sessions: refs }),
+  ]),
+});
+
+// POST /api/bus/groups { from, command } - `aos group …`, scoped to the
+// asking session's workspace like `aos read`.
+export async function POST(request: NextRequest) {
+  const parsed = body.safeParse(await request.json().catch(() => null));
+  if (!parsed.success)
+    return NextResponse.json(
+      { error: parsed.error.issues[0]?.message ?? "Bad request" },
+      { status: 400 }
+    );
+  try {
+    return NextResponse.json({
+      summary: groupCommand(parsed.data.from, parsed.data.command),
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const status = error instanceof GroupError ? GROUP_STATUS[error.code] : 409;
+    return NextResponse.json({ error: message }, { status });
+  }
+}

package/app/api/bus/spawn/route.ts

@@ -4,7 +4,9 @@ import { createTask } from "@/lib/tasks";
 import { startOrQueue, stampPriority } from "@/lib/tasks/queue";
 import { isPriority } from "@/lib/tasks/schedule-types";
 import { hostIdNamed } from "@/lib/hosts";
-import { startView } from "@/lib/sessions/launch";
+import { resolveGroup } from "@/lib/session-groups";
+import { launchSession, startView } from "@/lib/sessions/launch";
+import { isAgentRole } from "@/lib/models/agent-roles";
 import { callerSession, starterOf } from "@/lib/tasks/starter";
 import { callingDevice } from "@/lib/security/device-me";
 import {
@@ -33,6 +35,8 @@ export async function POST(request: NextRequest) {
       from,
       cwd,
       piece,
+      group,
+      agentRole,
     } = await request.json();
     // Whoever called: a session (by `from`, else the worktree it runs in) or a person.
     const starter = starterOf(
@@ -53,8 +57,15 @@ export async function POST(request: NextRequest) {
       throw new Error('machine is "mac" or "any"');
     if (piece !== undefined && mode !== "task")
       throw new Error("--piece works for tasks only");
+    const target = findProject(String(project ?? ""));
+    if (group !== undefined && (typeof group !== "string" || !group.trim()))
+      throw new Error("--group needs a group name");
+    const groupId =
+      typeof group === "string"
+        ? resolveGroup(target.workspace_id ?? null, group).id
+        : undefined;
     if (mode === "task") {
-      const projectId = findProject(String(project ?? "")).id;
+      const projectId = target.id;
       // A task whose plan has pieces waiting here must say which it builds.
       const waiting = startedBy ? waitingPiecesFor(startedBy, projectId) : [];
       let pieceId: number | undefined;
@@ -73,6 +84,7 @@ export async function POST(request: NextRequest) {
         model,
         hostId: on ? hostIdNamed(String(on)) : undefined,
         view: startView(view),
+        groupId,
         planOnly: planOnly === true ? true : undefined,
       };
       const out = await startOrQueue(
@@ -93,6 +105,25 @@ export async function POST(request: NextRequest) {
         ? NextResponse.json({ queued: out.queued, builds }, { status: 202 })
         : NextResponse.json({ session: out.started, builds }, { status: 201 });
     }
+    if (agentRole !== undefined) {
+      if (mode !== "session") throw new Error("--role works for spawn only");
+      if (!isAgentRole(agentRole))
+        throw new Error("--role is developer, analyst, reviewer or supervisor");
+      const { session } = await launchSession({
+        projectId: target.id,
+        agentType: "claude",
+        prompt,
+        name: given,
+        model: typeof model === "string" ? model : null,
+        autoApprove: true,
+        startedBy,
+        startedVia: starter.startedVia,
+        parentSessionId: starter.parentSessionId,
+        groupId,
+        agentRole,
+      });
+      return NextResponse.json({ session }, { status: 201 });
+    }
     const session = await spawnSession({
       project: String(project ?? ""),
       prompt,
@@ -100,6 +131,7 @@ export async function POST(request: NextRequest) {
       model,
       startedBy,
       parentSessionId: starter.parentSessionId,
+      groupId,
     });
     return NextResponse.json({ session }, { status: 201 });
   } catch (error) {

package/app/api/claims/[id]/route.ts

@@ -0,0 +1,20 @@
+import { NextResponse } from "next/server";
+import { endOutside } from "@/lib/claims";
+
+export const dynamic = "force-dynamic";
+
+// DELETE /api/claims/:id - an outside session ends its own claim. A task's
+// or another machine's claim can't be ended this way.
+export async function DELETE(
+  _request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const result = endOutside(id);
+  if (result === "forbidden")
+    return NextResponse.json(
+      { error: "Only an outside session's claim can be ended here" },
+      { status: 403 }
+    );
+  return NextResponse.json({ ok: true, ended: result === "ended" });
+}

package/app/api/claims/check/route.ts

@@ -0,0 +1,23 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { checkStart } from "@/lib/claims/startCheck";
+import { startWarning } from "@/lib/claims/startWarning";
+
+export const dynamic = "force-dynamic";
+
+const body = z.object({
+  projectId: z.string().min(1).max(100),
+  name: z.string().max(200).optional(),
+  prompt: z.string().max(100_000),
+  branch: z.string().max(250).nullable().optional(),
+});
+
+// POST /api/claims/check - before a person starts a task: who else is on the
+// same work. Reads claims and the repo's file list; never blocks a start.
+export async function POST(request: NextRequest) {
+  const parsed = body.safeParse(await request.json().catch(() => null));
+  if (!parsed.success)
+    return NextResponse.json({ error: "Bad check" }, { status: 400 });
+  const { overlaps } = await checkStart(parsed.data);
+  return NextResponse.json({ overlaps: overlaps.map(startWarning) });
+}

package/app/api/claims/check.test.ts

@@ -0,0 +1,113 @@
+import { execFileSync } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { NextRequest } from "next/server";
+import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { tempDir } from "@/lib/test-temp";
+import { seedWorkspace } from "@/lib/orchestrator/testing";
+
+const { db } = await import("@/lib/db");
+const { machineId } = await import("@/lib/claims/machine");
+const { upsertRemote } = await import("@/lib/claims/store");
+const { putSetting } = await import("@/lib/settings-store");
+const { POST } = await import("./check/route");
+
+const FILES = ["lib/auth/session.ts", "lib/auth/index.ts", "lib/auth/token.ts"];
+const REPO = "git.example.test/team/widgets";
+
+let dir: string;
+let projectId: string;
+
+const sh = (cwd: string, ...args: string[]) =>
+  execFileSync("git", args, { cwd, stdio: "pipe" });
+
+const check = (body: unknown) =>
+  POST(
+    new NextRequest("http://localhost/api/claims/check", {
+      method: "POST",
+      body: typeof body === "string" ? body : JSON.stringify(body),
+    })
+  );
+
+beforeAll(() => {
+  vi.spyOn(os, "homedir").mockReturnValue(tempDir("aos-claim-check-"));
+  dir = tempDir("claim-check-repo-");
+  sh(dir, "init", "-q", "-b", "main");
+  sh(dir, "config", "user.email", "t@example.test");
+  sh(dir, "config", "user.name", "t");
+  sh(dir, "remote", "add", "origin", "git@git.example.test:team/widgets.git");
+  for (const f of FILES) {
+    fs.mkdirSync(path.dirname(path.join(dir, f)), { recursive: true });
+    fs.writeFileSync(path.join(dir, f), "x");
+  }
+  sh(dir, "add", "-A");
+  sh(dir, "commit", "-q", "-m", "init");
+});
+
+beforeEach(() => {
+  db.prepare(`DELETE FROM work_claims`).run();
+  putSetting("claims.share", "on");
+  const t = seedWorkspace();
+  projectId = t.app.id;
+  db.prepare(`UPDATE projects SET working_directory = ? WHERE id = ?`).run(
+    dir,
+    projectId
+  );
+});
+
+const remote = (files: string[]) =>
+  upsertRemote(machineId(), "peer-1", {
+    id: "claim-box-1",
+    origin: "box-machine",
+    origin_name: "box",
+    hops: 0,
+    source: "session",
+    session_name: "Rework login sessions",
+    repo: REPO,
+    branch: "feature/login",
+    base: "main",
+    goal: "Rework login sessions",
+    files,
+    files_more: 0,
+    pr_url: null,
+    ttl_s: 600,
+    age_s: 60,
+    released: null,
+  });
+
+describe("POST /api/claims/check", () => {
+  it("refuses a body that isn't a check", async () => {
+    expect((await check("nope")).status).toBe(400);
+    expect((await check({ projectId })).status).toBe(400);
+    expect((await check({ projectId, prompt: 5 })).status).toBe(400);
+  });
+
+  it("says nothing when no one else is on the repo", async () => {
+    const res = await check({ projectId, prompt: "Tidy auth" });
+    expect(await res.json()).toEqual({ overlaps: [] });
+  });
+
+  it("returns the overlap with the other claim, strong first", async () => {
+    remote(FILES);
+    const res = await check({
+      projectId,
+      name: "Tidy auth",
+      prompt: `Touch ${FILES.join(" ")}`,
+    });
+    const { overlaps } = await res.json();
+    expect(overlaps).toHaveLength(1);
+    expect(overlaps[0]).toMatchObject({
+      strength: "strong",
+      claim: { id: "claim-box-1", machine: "box", branch: "feature/login" },
+    });
+    expect(overlaps[0].shared).toEqual([...FILES].sort());
+  });
+
+  it("returns no overlaps when sharing is off", async () => {
+    remote(FILES);
+    putSetting("claims.share", "off");
+    const res = await check({ projectId, prompt: `Touch ${FILES.join(" ")}` });
+    expect(await res.json()).toEqual({ overlaps: [] });
+  });
+});

package/app/api/claims/exchange/route.ts

@@ -0,0 +1,42 @@
+import { NextRequest, NextResponse } from "next/server";
+import { acceptExchange, answerExchange } from "@/lib/claims/exchange";
+import { claimsShared } from "@/lib/claims/machine";
+import { rememberPeer } from "@/lib/claims/peers";
+import { exchangeBody } from "@/lib/claims/types";
+import { pinForHost } from "@/lib/peer/links";
+import { PEER_HEADER, TRUST_HEADER } from "@/lib/security/auth";
+import { readCapped } from "@/lib/security/read-capped";
+
+export const dynamic = "force-dynamic";
+
+const MAX_BYTES = 2 * 1024 * 1024;
+
+// POST /api/claims/exchange - a linked machine sends its claims and gets
+// ours back. Paths and one-line goals only; the device-token gate applies.
+export async function POST(request: NextRequest) {
+  // A Connect peer arrives as `peer` trust naming its pin. The RPC layer has
+  // already refused suspended and unknown ones; a pin suspended since is
+  // refused here too.
+  let viaHost: string | null = null;
+  if (request.headers.get(TRUST_HEADER) === "peer") {
+    const hostId = request.headers.get(PEER_HEADER);
+    if (!hostId || pinForHost(hostId)?.state !== "active")
+      return NextResponse.json({ error: "forbidden" }, { status: 403 });
+    viaHost = hostId;
+  }
+  const raw = await readCapped(request, MAX_BYTES);
+  if (raw === null)
+    return NextResponse.json({ error: "Too large" }, { status: 413 });
+  let json: unknown;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    return NextResponse.json({ error: "Not JSON" }, { status: 400 });
+  }
+  const body = exchangeBody.safeParse(json);
+  if (!body.success)
+    return NextResponse.json({ error: "Bad claims" }, { status: 400 });
+  if (viaHost && claimsShared()) rememberPeer(viaHost, body.data.machine.id);
+  acceptExchange(body.data, viaHost);
+  return NextResponse.json(answerExchange(body.data));
+}