@tachikomagundam/abathur 0.1.0

package/dist/commands/graft.js

@@ -0,0 +1,71 @@
+// `abathur graft <bundle.tgz> --genome <label>` — thin CLI edge (plan todo 13):
+// flag parsing + registry lookup + stdout funnel. All gates, queue mechanics
+// and the local re-bench live in src/core/graft*.ts so the flow stays unit
+// testable and the CLI never touches process.
+import { homedir } from "node:os";
+import path from "node:path";
+import { resolveConfigDir } from "../config.js";
+import { readRegistry } from "../core/genome.js";
+import { graftBundle } from "../core/graft.js";
+import { cannotAnswer } from "../exit.js";
+import { writeStdout } from "../out.js";
+const USAGE = "usage: abathur graft <bundle.tgz> --genome <label>";
+function parseGraftFlags(args) {
+    let bundlePath = null;
+    let label = null;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--genome") {
+            const raw = args[(i += 1)];
+            if (raw === undefined || raw.length === 0 || raw.startsWith("--"))
+                cannotAnswer("graft: --genome <label> requires a value", USAGE);
+            label = raw;
+        }
+        else if (arg.startsWith("--")) {
+            cannotAnswer(`graft: unknown flag ${arg}`, `${USAGE}\n  no bypass flag exists — quarantine and pending-bench are decisions, not warnings`);
+        }
+        else if (bundlePath !== null) {
+            cannotAnswer(`graft: unexpected extra argument '${arg}'`, USAGE);
+        }
+        else {
+            bundlePath = arg;
+        }
+    }
+    if (bundlePath === null)
+        cannotAnswer("graft: <bundle.tgz> is required", USAGE);
+    if (label === null)
+        cannotAnswer("graft: --genome <label> is required", USAGE);
+    return { bundlePath, label };
+}
+/** Registry lookup WITHOUT run.ts's resolveUniqueEntry so an unregistered
+ *  label can reach the pending-bench queue path instead of exiting 2. */
+function entryForLabel(configDir, label) {
+    const matches = readRegistry(configDir).entries.filter((entry) => entry.label === label);
+    if (matches.length > 1) {
+        cannotAnswer(`graft: label '${label}' is ambiguous — ${String(matches.length)} genomes share it: ${matches
+            .map((e) => `${e.fingerprint} @ ${e.spec.repoPath}`)
+            .join(", ")}`, "give the specs distinct labels; the fingerprint is the identity");
+    }
+    return matches[0] ?? null;
+}
+async function runGraft(context) {
+    const flags = parseGraftFlags(context.args);
+    const configDir = resolveConfigDir();
+    const outcome = await graftBundle({
+        entry: entryForLabel(configDir, flags.label),
+        configDir,
+        bundlePath: path.resolve(flags.bundlePath),
+        genomeLabel: flags.label,
+        home: homedir(),
+        opencodeBin: context.loaded.config.opencodeBin,
+        env: process.env,
+    });
+    for (const line of outcome.lines)
+        writeStdout(line);
+    return outcome.exitCode;
+}
+export const graftCommand = {
+    name: "graft",
+    summary: "import an offline bundle and graft its lineage",
+    run: (context) => runGraft(context),
+};

package/dist/commands/kernel.js

@@ -0,0 +1,47 @@
+// `abathur kernel audit <label>` — read-only seal check (todo 4). Promote-time
+// reseal/generation stays with todo 10; this router only reports drift so the
+// validation loop (todo 9) and gate can consume the same auditKernel() result.
+import { resolveConfigDir } from "../config.js";
+import { requireGenomesByLabel } from "../core/genome.js";
+import { auditKernel } from "../core/kernel.js";
+import { EXIT_OK, blocked, cannotAnswer } from "../exit.js";
+import { writeStdout } from "../out.js";
+function kernelAudit(configDir, args) {
+    const label = args[0];
+    if (label === undefined || label.length === 0) {
+        cannotAnswer("kernel audit: missing <label> argument", "usage: abathur kernel audit <label>");
+    }
+    const scan = requireGenomesByLabel(configDir, label);
+    for (const warning of scan.warnings)
+        writeStdout(`warning: ${warning}`);
+    const failures = [];
+    for (const entry of scan.entries) {
+        const audit = auditKernel(entry, configDir);
+        if (audit.ok) {
+            writeStdout(`sealed clean: '${entry.label}' (${entry.fingerprint})`);
+        }
+        else {
+            failures.push(...audit.drifted.map((d) => `${entry.label} (${entry.fingerprint}): ${d.path} ${d.kind}`));
+        }
+    }
+    if (failures.length > 0) {
+        blocked(`kernel audit FAILED for '${label}':\n  - ${failures.slice(0, 10).join("\n  - ")}` +
+            `${failures.length > 10 ? `\n  - (+${String(failures.length - 10)} more)` : ""}`, "restore the named files or resolve the drift at promote — 'genome add' cannot reseal");
+    }
+    return EXIT_OK;
+}
+function runKernel(args) {
+    const configDir = resolveConfigDir();
+    const [sub, ...rest] = args;
+    switch (sub) {
+        case "audit":
+            return kernelAudit(configDir, rest);
+        default:
+            return cannotAnswer(`kernel: unknown subcommand '${sub ?? "<none>"}'`, "usage: abathur kernel audit <label> (promote-time reseal arrives with todo 10)");
+    }
+}
+export const kernelCommand = {
+    name: "kernel",
+    summary: "audit frozen kernel seals against the working tree",
+    run: ({ args }) => runKernel(args),
+};

package/dist/commands/promote.js

@@ -0,0 +1,25 @@
+// `abathur promote <label> <genId>` — the ONLY entry point to the human gate
+// (plan Must NOT: no auto-promote path importable by evolve modules). No --force:
+// every refusal is a bug report, not a flag.
+import { resolveConfigDir } from "../config.js";
+import { EXIT_OK, cannotAnswer } from "../exit.js";
+import { promoteGeneration } from "../core/promote.js";
+import { writeStdout } from "../out.js";
+import { resolveUniqueEntry } from "./run.js";
+const USAGE = "usage: abathur promote <label> <genId>";
+async function runPromote(args) {
+    const [label, genId] = args;
+    if (label === undefined || genId === undefined || args.length !== 2)
+        cannotAnswer(`promote: expected exactly <label> <genId>`, USAGE);
+    const configDir = resolveConfigDir();
+    const entry = resolveUniqueEntry(configDir, label, "promote");
+    const outcome = await promoteGeneration({ entry, configDir, genId });
+    for (const line of outcome.lines)
+        writeStdout(line);
+    return EXIT_OK;
+}
+export const promoteCommand = {
+    name: "promote",
+    summary: "human gate: promote a nominated gen (ledger-verified, sealed-path re-check, fast-forward + manifest regen)",
+    run: ({ args }) => runPromote(args),
+};

package/dist/commands/run.js

@@ -0,0 +1,145 @@
+// `abathur run` — thin CLI edge (plan todo 9): flag parsing + registry lookup +
+// stdout funnel only; every gate and the whole evolution loop live in
+// src/core/evolve/run-loop.ts (runEvolution), so the loop stays unit-testable.
+import { resolveConfigDir } from "../config.js";
+import { readRegistry, requireGenomesByLabel } from "../core/genome.js";
+import { appendRunFriction } from "../core/evolve/friction.js";
+import { runEvolution } from "../core/evolve/run-loop.js";
+import { cannotAnswer, ExitSignal } from "../exit.js";
+import { writeStdout } from "../out.js";
+const USAGE = "usage: abathur run --genome <label> [--reps N] [--max-candidates N] [--mutator <template>] [--dry-run] [--include-val]";
+function positiveInt(raw, flag) {
+    if (raw === undefined || raw.length === 0 || raw.startsWith("--")) {
+        cannotAnswer(`run: ${flag} requires a positive integer value`, USAGE);
+    }
+    const value = Number(raw);
+    if (!Number.isInteger(value) || value < 1) {
+        cannotAnswer(`run: ${flag} expects a positive integer, got '${raw}'`, USAGE);
+    }
+    return value;
+}
+export function parseRunFlags(args) {
+    let label = null;
+    let reps = null;
+    let maxCandidates = null;
+    let mutator = null;
+    let dryRun = false;
+    let includeVal = false;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        const next = () => args[(i += 1)];
+        switch (arg) {
+            case "--genome": {
+                const raw = next();
+                if (raw === undefined || raw.length === 0 || raw.startsWith("--")) {
+                    cannotAnswer("run: --genome <label> requires a value", USAGE);
+                }
+                label = raw;
+                break;
+            }
+            case "--reps":
+                reps = positiveInt(next(), "--reps");
+                break;
+            case "--max-candidates":
+                maxCandidates = positiveInt(next(), "--max-candidates");
+                break;
+            case "--mutator": {
+                const raw = next();
+                if (raw === undefined || raw.length === 0 || raw.startsWith("--"))
+                    cannotAnswer("run: --mutator <template> requires a value", USAGE);
+                mutator = raw;
+                break;
+            }
+            case "--dry-run":
+                dryRun = true;
+                break;
+            case "--include-val":
+                includeVal = true;
+                break;
+            default:
+                cannotAnswer(`run: unknown flag ${arg}`, USAGE);
+        }
+    }
+    if (label === null)
+        cannotAnswer("run: --genome <label> is required", USAGE);
+    return { label, reps, maxCandidates, mutator, dryRun, includeVal };
+}
+/** Labels are free (todo 4): a command needs ONE genome, so duplicates are an explicit exit 2. */
+export function resolveUniqueEntry(configDir, label, who = "run") {
+    const scan = requireGenomesByLabel(configDir, label);
+    if (scan.entries.length > 1) {
+        cannotAnswer(`${who}: label '${label}' is ambiguous — ${String(scan.entries.length)} genomes share it: ${scan.entries
+            .map((e) => `${e.fingerprint} @ ${e.spec.repoPath}`)
+            .join(", ")}`, "give the specs distinct labels; the fingerprint is the identity");
+    }
+    const entry = scan.entries[0];
+    if (entry === undefined)
+        cannotAnswer(`${who}: no registered genome with label '${label}'`);
+    return entry;
+}
+const ZERO_COUNTS = { applied: 0, rejected: 0, benched: 0, inconclusive: 0, nominated: 0, timeouts: 0, reaped: 0 };
+async function runRun(context) {
+    const flags = parseRunFlags(context.args);
+    const configDir = resolveConfigDir();
+    for (const warning of readRegistry(configDir).warnings)
+        writeStdout(`warning: ${warning}`);
+    const entry = resolveUniqueEntry(configDir, flags.label);
+    const warnings = [];
+    const frictionSink = (input) => {
+        try {
+            appendRunFriction(configDir, input);
+        }
+        catch (error) {
+            warnings.push(`friction: append failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    };
+    // Friction is the self-evolution SIGNAL channel (todo 11): every real run
+    // books one structured run-summary record, and every refusal that happens
+    // after the registry resolved books a cli-error record — in both cases the
+    // queue append can never break or change the run's own exit status.
+    let outcome;
+    try {
+        outcome = await runEvolution({
+            entry,
+            configDir,
+            opencodeBin: context.loaded.config.opencodeBin,
+            ...(flags.reps === null ? {} : { reps: flags.reps }),
+            ...(flags.maxCandidates === null ? {} : { maxCandidates: flags.maxCandidates }),
+            ...(flags.mutator === null ? {} : { mutatorCommand: flags.mutator }),
+            ...(flags.dryRun ? { dryRun: true } : {}),
+            ...(flags.includeVal ? { includeVal: true } : {}),
+            friction: frictionSink,
+        });
+    }
+    catch (error) {
+        if (error instanceof ExitSignal) {
+            try {
+                appendRunFriction(configDir, {
+                    genomeFp: entry.fingerprint,
+                    cause: "cli-error",
+                    exit: error.code,
+                    complete: false,
+                    counts: ZERO_COUNTS,
+                    rejected: [],
+                    units: [],
+                    reasons: [error.message],
+                    stall: { budgetTruncated: false, orphanGroups: 0 },
+                });
+            }
+            catch {
+                // the refusal stands on its own; a dead queue never masks it.
+            }
+        }
+        throw error;
+    }
+    for (const line of outcome.lines)
+        writeStdout(line);
+    for (const warning of warnings)
+        writeStdout(warning);
+    return outcome.exitCode;
+}
+export const runCommand = {
+    name: "run",
+    summary: "evolve one genome: observe, mutate, re-bench, select",
+    run: (context) => runRun(context),
+};

package/dist/commands/self-eval.js

@@ -0,0 +1,240 @@
+// `abathur self-eval` — REPORT ONLY (plan todo 11c): grade abathur-self
+// candidates by the snapshot-overlay bench (candidate src under the incumbent's
+// trusted tests + golden toy-replay) and print verdicts. It grants NO promote
+// authority — the operator-side `abathur promote` stays the only merge path
+// (structural test in src/test/friction.test.ts forbids importing promote from
+// here), it writes NO ledger rows (reads the ledger raw, status.ts pattern),
+// and its only persistent output is one self-eval friction record appended to
+// the global queue. Single-shot like graft: crash → re-run, nothing to resume.
+//
+// Kernel audit FIRST (same gate order as `run`): a tampered seal means the
+// trusted tree itself is untrustworthy, so scoring refuses with exit 1 BEFORE
+// any snapshot, spawn, or state exists.
+import { resolveConfigDir } from "../config.js";
+import { readRegistry } from "../core/genome.js";
+import { auditKernel } from "../core/kernel.js";
+import { ledgerPath, ledgerRecordSchema } from "../core/ledger.js";
+import { existsSync, readFileSync } from "node:fs";
+import { asReplicates } from "../core/evolve/run-bench.js";
+import { decodeGenerationRecord } from "../core/evolve/run-rows.js";
+import { runExitCode } from "../core/evolve/run-loop.js";
+import { appendRunFriction, scrub } from "../core/evolve/friction.js";
+import { selfBench, selfGuardVerdict } from "../core/evolve/self-snapshot.js";
+import { effectiveRepoPath, isEnvRepoLiteral } from "../core/spec.js";
+import { clampReps, evaluate } from "../core/stats.js";
+import { blocked, cannotAnswer } from "../exit.js";
+import { genId, fingerprint } from "../core/ids.js";
+import { openGenome } from "../core/worktree.js";
+import { writeStdout } from "../out.js";
+import { resolveUniqueEntry } from "./run.js";
+const USAGE = "usage: abathur self-eval [--genome abathur-self] [--gen <genId>]... [--reps N]";
+function parseFlags(args) {
+    let label = "abathur-self";
+    const gens = [];
+    let reps = null;
+    let index = 0;
+    const next = (flag) => {
+        index += 1;
+        const raw = args[index];
+        if (raw === undefined || raw.length === 0 || raw.startsWith("--"))
+            cannotAnswer(`self-eval: ${flag} requires a value`, USAGE);
+        return raw;
+    };
+    while (index < args.length) {
+        const arg = args[index];
+        if (arg === undefined)
+            break;
+        switch (arg) {
+            case "--genome":
+                label = next(arg);
+                break;
+            case "--gen":
+                gens.push(next(arg));
+                break;
+            case "--reps": {
+                const value = Number(next(arg));
+                if (!Number.isInteger(value) || value < 1)
+                    cannotAnswer("self-eval: --reps expects a positive integer", USAGE);
+                reps = value;
+                break;
+            }
+            default:
+                cannotAnswer(`self-eval: unknown flag ${arg}`, USAGE);
+        }
+        index += 1;
+    }
+    return { label, gens, reps };
+}
+function candidateRows(genomeRepo) {
+    const file = ledgerPath(genomeRepo);
+    if (!existsSync(file))
+        return [];
+    const out = [];
+    const lines = readFileSync(file, "utf8").split("\n");
+    if (lines.at(-1) === "")
+        lines.pop();
+    lines.forEach((line, index) => {
+        const value = JSON.parse(line);
+        const parsed = ledgerRecordSchema.safeParse(value);
+        if (!parsed.success) {
+            cannotAnswer(`self-eval: ${file}: line ${String(index + 1)} failed ledger schema validation: ${parsed.error.message}`, "the ledger is append-only truth — repair by hand");
+        }
+        const record = parsed.data;
+        if (record.kind !== "generation_complete" || record.genId === undefined)
+            return;
+        const data = decodeGenerationRecord(record);
+        if (data.source === "candidate" && data.commitSha !== undefined)
+            out.push({ genId: record.genId, commit: data.commitSha, data });
+    });
+    return out;
+}
+function suiteText(res) {
+    if (res.suiteRuns.length === 0)
+        return `suite ${res.buildStatus === "timeout" ? "BUILD TIMEOUT" : res.buildStatus === "failed" ? "BUILD FAILED" : "no samples"}`;
+    return `suite ${res.suiteRuns.map((r) => `${String(r.pass)}/${String(r.tests)}`).join(" ")}`;
+}
+function unitEvidence(res, into) {
+    for (const row of res.units) {
+        const prior = into.get(row.unitId);
+        into.set(row.unitId, {
+            unitId: row.unitId,
+            split: row.split,
+            scores: prior === undefined ? [...row.scores] : [...prior.scores, ...row.scores],
+            failures: prior === undefined ? [...row.failures] : [...prior.failures, ...row.failures],
+        });
+    }
+}
+async function selfEvalHandler(context) {
+    const flags = parseFlags(context.args);
+    const configDir = resolveConfigDir();
+    for (const warning of readRegistry(configDir).warnings)
+        writeStdout(`warning: ${warning}`);
+    const entry = resolveUniqueEntry(configDir, flags.label, "self-eval");
+    if (!isEnvRepoLiteral(entry.spec.repoPath)) {
+        cannotAnswer(`self-eval: '${entry.spec.label}' is not a self genome — repoPath must be the \${ABATHUR_SELF_REPO} literal`, "self-eval grades the harness against its own sealed kernel; see genomes/abathur-self.jsonc");
+    }
+    const audit = auditKernel(entry, configDir);
+    if (!audit.ok) {
+        const listed = audit.drifted.map((d) => `${d.path} (${d.kind})`);
+        blocked(`self-eval refused: kernel drift for '${entry.spec.label}' (${entry.fingerprint}): ${listed.slice(0, 10).join(", ")}${listed.length > 10 ? ` (+${String(listed.length - 10)} more)` : ""}`, "restore the sealed files or resolve drift via 'abathur kernel' — self-eval never reseals and never scores on a tampered trusted tree");
+    }
+    const spec = entry.spec;
+    const genomeRepo = effectiveRepoPath(spec.repoPath);
+    const opened = await openGenome(genomeRepo, [], {});
+    const recorded = candidateRows(genomeRepo);
+    const byGen = new Map();
+    for (const row of recorded)
+        byGen.set(row.genId, row); // latest row per genId wins (append order)
+    let picked = [...byGen.values()];
+    if (flags.gens.length > 0) {
+        const wanted = new Set(flags.gens);
+        const missing = flags.gens.filter((g) => !byGen.has(g));
+        if (missing.length > 0)
+            blocked(`self-eval: no candidate generation rows for ${missing.map((m) => `'${m}'`).join(", ")} in '${entry.spec.label}'`, `known candidates: ${[...byGen.keys()].join(", ") || "(none)"}`);
+        picked = picked.filter((row) => wanted.has(row.genId));
+    }
+    if (picked.length === 0) {
+        cannotAnswer(`self-eval: no candidate generations recorded for '${entry.spec.label}' — run evolution first`, `abathur run --genome ${entry.spec.label} --mutator <template>`);
+    }
+    const reps = clampReps(flags.reps ?? undefined, spec.bench.stats.nReps);
+    const caps = {
+        maxCandidates: spec.budget.maxCandidates,
+        maxModelCalls: spec.budget.maxModelCalls,
+        maxTokens: spec.budget.maxTokens,
+        maxWallS: spec.budget.maxWallS,
+    };
+    const invRunId = genId(fingerprint({ selfEval: opened.headCommit, at: Date.now() }));
+    writeStdout(`self-eval ${entry.spec.label} fp ${entry.fingerprint} incumbent ${opened.headCommit.slice(0, 12)} reps ${String(reps)}`);
+    const incumbent = await selfBench({
+        spec,
+        genomeRepo,
+        genomeFp: entry.fingerprint,
+        incumbentCommit: opened.headCommit,
+        candidateCommit: null,
+        genId: `${invRunId}-base`,
+        reps,
+        env: process.env,
+    });
+    writeStdout(`  baseline: ${suiteText(incumbent)}, replay observed ${incumbent.replayDigest ?? "n/a"} expected ${incumbent.replayExpected}`);
+    const evidence = new Map();
+    unitEvidence(incumbent, evidence);
+    let counters = { candidates: 0, modelCalls: 0, tokens: 0, wallS: incumbent.spent.wallS };
+    const verdicts = [];
+    const reasons = [];
+    for (const row of picked) {
+        const res = await selfBench({
+            spec,
+            genomeRepo,
+            genomeFp: entry.fingerprint,
+            incumbentCommit: opened.headCommit,
+            candidateCommit: row.commit,
+            genId: row.genId,
+            reps,
+            env: process.env,
+        });
+        unitEvidence(res, evidence);
+        counters = { ...counters, candidates: counters.candidates + 1, wallS: counters.wallS + res.spent.wallS };
+        const gate = evaluate({
+            candidate: { runId: invRunId, units: asReplicates(res.units), counters },
+            incumbent: { units: asReplicates(incumbent.units) },
+            stats: spec.bench.stats,
+            budgetCaps: caps,
+            nPairs: Math.max(1, picked.length),
+        });
+        const verdict = selfGuardVerdict(res.failures, gate.verdict);
+        verdicts.push(verdict);
+        const gain = gate.gain === null || !Number.isFinite(gate.gain) ? "n/a" : gate.gain.toFixed(4);
+        writeStdout(`candidate ${row.data.candidateId ?? row.genId} [gen ${row.genId} tree ${(row.data.treeSha ?? "").slice(0, 12)}]: verdict ${verdict} (gain ${gain}, ${suiteText(res)}, replay observed ${res.replayDigest ?? "n/a"} expected ${res.replayExpected}, overlay ${String(res.overlaid.length)} files, dropped ${String(res.dropped.length)})`);
+        if (res.buildStatus !== "ok")
+            writeStdout(`  build ${res.buildStatus}: ${scrub(res.buildNote, 200)}`);
+        if (res.overlaid.length > 0) {
+            const shown = res.overlaid.slice(0, 10).join(", ");
+            writeStdout(`  overlay: ${shown}${res.overlaid.length > 10 ? ` (+${String(res.overlaid.length - 10)} more)` : ""}`);
+        }
+        for (const reason of ["sealed", "trusted-tests"]) {
+            const dropped = res.dropped.filter((d) => d.reason === reason);
+            if (dropped.length > 0)
+                writeStdout(`  dropped (${reason}): ${dropped.map((d) => d.path).join(", ")}`);
+        }
+        for (const failure of gate.failures)
+            writeStdout(`  gate: ${failure}`);
+        if (verdict !== gate.verdict)
+            writeStdout(`  guard: self-bench downgraded ${gate.verdict} -> ${verdict} (see overlay-empty/build-timeout rule)`);
+        for (const note of res.failures)
+            if (note.startsWith("self-bench:"))
+                reasons.push(`${row.data.candidateId ?? row.genId}: ${scrub(note, 200)}`);
+    }
+    const exit = runExitCode(verdicts);
+    const timeouts = [...evidence.values()].reduce((n, u) => n + u.failures.filter((f) => f.includes(": run timeout") || f.includes("build timeout")).length, 0);
+    const input = {
+        genomeFp: entry.fingerprint,
+        cause: "self-eval",
+        exit,
+        complete: incumbent.complete && verdicts.every((v) => v !== "inconclusive"),
+        counts: {
+            applied: 0,
+            rejected: 0,
+            benched: picked.length + 1,
+            inconclusive: verdicts.filter((v) => v === "inconclusive").length,
+            nominated: verdicts.filter((v) => v === "nominated").length,
+            timeouts,
+            reaped: 0,
+        },
+        rejected: [],
+        units: [...evidence.values()],
+        reasons: [`self-eval ${entry.spec.label}: ${String(picked.length)} candidate(s) over snapshot-overlay bench`, ...reasons],
+        stall: { budgetTruncated: !incumbent.complete, orphanGroups: 0 },
+    };
+    try {
+        appendRunFriction(configDir, input);
+    }
+    catch (error) {
+        writeStdout(`friction: append failed: ${error instanceof Error ? scrub(error.message, 200) : String(error)}`);
+    }
+    return exit;
+}
+export const selfEvalCommand = {
+    name: "self-eval",
+    summary: "evaluate the harness itself (abathur-self genome)",
+    run: (context) => selfEvalHandler(context),
+};