@tea-agent/loop-agent 0.22.0 → 0.24.0

package/dist/worker/console/chat/tools.js

@@ -0,0 +1,195 @@
+/**
+ * Operator Chat — closed tool whitelist (design §7.5 / roadmap M0).
+ *
+ * The Chat exposes the model-callable structured operator surface. Repository
+ * exploration is deliberately limited to safe-read/safe-grep/git-status/
+ * git-diff plus built-in find/ls; the bare SDK bash/read/grep tools are denied
+ * because they bypass the M0-A write and sensitive-data boundaries.
+ *
+ * Dynamic discovery derives model-callable operator actions directly from the
+ * capabilities registry. Explicit denial remains the defense-in-depth layer:
+ * a future resource-loader or SDK drift cannot reactivate removed coding or
+ * explore tools merely by changing the active-tool list.
+ */
+import { buildOperatorCapabilitiesDocument } from "../../../shared/operator/capabilities.js";
+import { OFFICIAL_DENIED_TOOL_IDS } from "../resource-loader.js";
+import { EXECUTABLE_GATE_ONLY_ACTIONS } from "./tool-adapter.js";
+const EXECUTABLE_GATE_ONLY = new Set(EXECUTABLE_GATE_ONLY_ACTIONS);
+/**
+ * Actions the model MAY invoke. Derived from the registry but filtered by the
+ * modelCallable policy: modelCallable="never" actions (e.g. confirmDagConfirmation)
+ * are the human confirmation itself and MUST NOT be model-callable (roadmap
+ * M0-B / G03). They are never registered as Pi tools AND denied at the gate.
+ */
+export const OPERATOR_CHAT_ALLOWED_TOOLS = Object.freeze(buildOperatorCapabilitiesDocument()
+    .actions.filter((a) => a.modelCallable !== "never" && !EXECUTABLE_GATE_ONLY.has(a.action))
+    .map((a) => a.action));
+/**
+ * Operator actions that MUST NOT be model-callable (roadmap M0-B / G03).
+ * Derived from the registry's modelCallable="never" policy. These are the
+ * human confirmation actions (confirmDagConfirmation) — the model can only
+ * prepare them; the browser mutation gate executes the confirm with a
+ * server-signed confirmation token.
+ */
+export const OPERATOR_CHAT_MODEL_FORBIDDEN_ACTIONS = Object.freeze(buildOperatorCapabilitiesDocument()
+    .actions.filter((a) => a.modelCallable === "never" || EXECUTABLE_GATE_ONLY.has(a.action))
+    .map((a) => a.action));
+/**
+ * Operator actions denied by the legacy MVP boundary. Kept EMPTY since the
+ * owner decided (2026-07-25) that the full operator surface is Chat-callable.
+ * Retained (empty) so downstream guards referencing it keep compiling and
+ * stay defensive against future additions.
+ */
+export const OPERATOR_CHAT_DENIED_OPERATOR_ACTIONS = Object.freeze([]);
+// Coding / generic tool ids that must never appear in a Chat session. M0-A
+// removes bare bash (write-via-redirect) and SDK read/grep (no sensitive-file
+// boundary); find/ls remain the only SDK explore builtins. Safe content probes
+// are custom tools, not generic SDK tools.
+const _ALLOWED_SDK_EXPLORE_TOOLS = new Set(["find", "ls"]);
+const _REMOVED_SDK_EXPLORE_TOOLS = ["bash", "read", "grep"];
+// Operator actions that OFFICIAL_DENIED_TOOL_IDS carries for Interview safety
+// but that the Chat now deliberately allows. We compare on a COMPACTED form
+// (strip - and _) because OFFICIAL lists both camelCase (`contractApply`) and
+// snake_case (`contract_apply`) variants, and authorize() also normalizes —
+// leaving any variant in would re-deny the action via normalization.
+const _ALLOWED_OPERATOR_ACTIONS_COMPACT = new Set(OPERATOR_CHAT_ALLOWED_TOOLS.map((t) => t.toLowerCase().replace(/[-_]/g, "")));
+export const OPERATOR_CHAT_DENIED_TOOLS = Object.freeze([
+    ...new Set([
+        ...OFFICIAL_DENIED_TOOL_IDS.filter((id) => {
+            const lower = id.toLowerCase();
+            if (_ALLOWED_SDK_EXPLORE_TOOLS.has(lower))
+                return false;
+            if (_ALLOWED_OPERATOR_ACTIONS_COMPACT.has(lower.replace(/[-_]/g, ""))) {
+                return false;
+            }
+            return true;
+        }),
+        ..._REMOVED_SDK_EXPLORE_TOOLS,
+    ]),
+]);
+/**
+ * Operator actions denied by model policy (modelCallable="never"). These are
+ * human-only actions (the confirmation itself) — derived from the registry so
+ * adding a "never" policy there is the only edit needed. Kept separate from
+ * OPERATOR_CHAT_DENIED_OPERATOR_ACTIONS (legacy empty MVP boundary list) to
+ * preserve the two distinct concerns (model policy vs MVP mutation boundary).
+ */
+const DENIED_MODEL_POLICY = new Set(OPERATOR_CHAT_MODEL_FORBIDDEN_ACTIONS.map((a) => a.toLowerCase()));
+const ALLOWED = new Set(OPERATOR_CHAT_ALLOWED_TOOLS.map((t) => t.toLowerCase()));
+const DENIED_ACTIONS = new Set(OPERATOR_CHAT_DENIED_OPERATOR_ACTIONS.map((a) => a.toLowerCase()));
+const DENIED_TOOLS = new Set(OPERATOR_CHAT_DENIED_TOOLS.map((t) => t.toLowerCase()));
+export function isOperatorChatToolAllowed(toolId) {
+    return ALLOWED.has(toolId.trim().toLowerCase());
+}
+export function isOperatorChatToolDenied(toolId) {
+    const id = toolId.trim().toLowerCase();
+    if (DENIED_TOOLS.has(id))
+        return true;
+    if (DENIED_ACTIONS.has(id))
+        return true;
+    // modelCallable="never" actions are always denied to the model (roadmap G03).
+    if (DENIED_MODEL_POLICY.has(id))
+        return true;
+    // normalize snake/camel/kebab
+    const compact = id.replace(/[-_]/g, "");
+    for (const d of DENIED_TOOLS) {
+        if (d.replace(/[-_]/g, "") === compact)
+            return true;
+    }
+    for (const d of DENIED_ACTIONS) {
+        if (d.replace(/[-_]/g, "") === compact)
+            return true;
+    }
+    for (const d of DENIED_MODEL_POLICY) {
+        if (d.replace(/[-_]/g, "") === compact)
+            return true;
+    }
+    return false;
+}
+/**
+ * Three-gate authorization (design §7.5): session create / setActiveTools /
+ * per-tool-call. Server-side only — UI hiding is insufficient.
+ */
+export function authorizeOperatorChatTool(toolId) {
+    const id = toolId.trim();
+    if (!id) {
+        return {
+            ok: false,
+            code: "tool-unknown",
+            toolId: id,
+            message: "empty tool id is not allowed in General Operator Chat",
+        };
+    }
+    if (isOperatorChatToolDenied(id)) {
+        return {
+            ok: false,
+            code: "tool-denied",
+            toolId: id,
+            message: `tool "${id}" is denied in General Operator Chat (no bash/read/grep/edit/write/apply_patch/full-tools/shell/coding-chat)`,
+        };
+    }
+    if (!isOperatorChatToolAllowed(id)) {
+        return {
+            ok: false,
+            code: "tool-unknown",
+            toolId: id,
+            message: `tool "${id}" is not registered for General Operator Chat (new operator actions default to deny)`,
+        };
+    }
+    return { ok: true, toolId: id };
+}
+/**
+ * Filter a requested tool list against the Chat whitelist.
+ * Returns allowed + denied (for diagnostics / red-team evidence).
+ */
+export function filterOperatorChatTools(requested) {
+    const allowed = [];
+    const denied = [];
+    for (const toolId of requested) {
+        const decision = authorizeOperatorChatTool(toolId);
+        if (decision.ok)
+            allowed.push(decision.toolId);
+        else
+            denied.push(toolId);
+    }
+    return { allowed, denied };
+}
+/**
+ * Assert that a requested tool set contains no prohibited coding or removed
+ * SDK explore tool. Used by red-team / boot checks (V12 / M0-A). bash is
+ * explicitly forbidden: accepting it would recreate the redirect write escape.
+ */
+export function assertNoWriteToolInList(requested) {
+    const writeVariants = [
+        "edit",
+        "write",
+        "apply_patch",
+        "apply-patch",
+        "full-tools",
+        "full_tools",
+        "coding-chat",
+        "coding_chat",
+        "shell",
+        "bash",
+        "read",
+        "grep",
+    ];
+    const lower = new Set(requested.map((t) => t.trim().toLowerCase()));
+    for (const v of writeVariants) {
+        if (lower.has(v)) {
+            throw new Error(`file-writing tool "${v}" must not appear in Operator Chat tool list (V12 closed coding surface)`);
+        }
+    }
+}
+/**
+ * Back-compat alias kept for callers that still reference the old name. It
+ * also rejects removed SDK explore tools, including bash.
+ * @deprecated use {@link assertNoWriteToolInList}.
+ */
+export function assertNoBashInToolList(requested) {
+    assertNoWriteToolInList(requested);
+}
+/** Canonical sorted tool list to hand to setActiveToolsByName. */
+export function canonicalOperatorChatToolList() {
+    return [...OPERATOR_CHAT_ALLOWED_TOOLS].sort();
+}

package/dist/worker/console/chat/usage.js

@@ -0,0 +1,37 @@
+function record(value) {
+    return value && typeof value === "object" ? value : undefined;
+}
+function numberAt(source, keys) {
+    for (const key of keys)
+        if (typeof source[key] === "number" && Number.isFinite(source[key]))
+            return Math.max(0, source[key]);
+    return undefined;
+}
+export function extractUsageSample(value) {
+    const event = record(value);
+    if (!event)
+        return undefined;
+    const message = record(event.message);
+    const source = record(event.usage) ?? record(message?.usage) ?? record(event.tokenUsage);
+    if (!source)
+        return undefined;
+    const inputTokens = numberAt(source, ["input_tokens", "inputTokens", "prompt_tokens", "promptTokens"]);
+    const outputTokens = numberAt(source, ["output_tokens", "outputTokens", "completion_tokens", "completionTokens"]);
+    const totalTokens = numberAt(source, ["total_tokens", "totalTokens"]) ?? (inputTokens !== undefined || outputTokens !== undefined ? (inputTokens ?? 0) + (outputTokens ?? 0) : undefined);
+    if (inputTokens === undefined && outputTokens === undefined && totalTokens === undefined)
+        return undefined;
+    const responseKey = [event.responseId, message?.id, source.responseId].find((item) => typeof item === "string");
+    return { inputTokens, outputTokens, totalTokens, ...(responseKey ? { responseKey } : {}) };
+}
+export function aggregateUsage(samples) {
+    const keyed = new Map();
+    const anonymous = [];
+    for (const sample of samples)
+        sample.responseKey ? keyed.set(sample.responseKey, sample) : anonymous.push(sample);
+    const selected = [...keyed.values(), ...anonymous];
+    return selected.reduce((sum, sample) => ({
+        inputTokens: sum.inputTokens + (sample.inputTokens ?? 0), outputTokens: sum.outputTokens + (sample.outputTokens ?? 0), totalTokens: sum.totalTokens + (sample.totalTokens ?? ((sample.inputTokens ?? 0) + (sample.outputTokens ?? 0))),
+        cost: sample.cost === undefined ? sum.cost : (sum.cost ?? 0) + sample.cost,
+        estimated: Boolean(sum.estimated || sample.estimated),
+    }), { inputTokens: 0, outputTokens: 0, totalTokens: 0 });
+}

package/dist/worker/console/chat/workspace-landing.js

@@ -0,0 +1,56 @@
+export const ACTIVE_CHAT_SESSION_STORAGE_KEY = "loop-console.operator-chat.active-session.v1";
+export const DEFAULT_LANDING_STORAGE_KEY = "loop-console.operator-chat.default-landing.v1";
+function configuredLanding(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "chat")
+        return "chat";
+    if (normalized === "tasks")
+        return "tasks";
+    return undefined;
+}
+function configuredWorkspace(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "chat" || normalized === "tasks" || normalized === "recovery")
+        return normalized;
+    return undefined;
+}
+function workspaceFromLocation(location) {
+    if (!location)
+        return undefined;
+    const query = new URLSearchParams(location.search);
+    const queryValue = configuredLanding(query.get("landing") ?? query.get("workspace"));
+    if (queryValue)
+        return queryValue;
+    const hash = location.hash.startsWith("#") ? location.hash.slice(1) : location.hash;
+    return configuredLanding(new URLSearchParams(hash).get("workspace"));
+}
+export function resolveDefaultLanding(input) {
+    return workspaceFromLocation(input.location) ??
+        configuredLanding(input.storage?.getItem(DEFAULT_LANDING_STORAGE_KEY)) ??
+        configuredLanding(input.env) ??
+        "tasks";
+}
+export function buildWorkspaceHref(workspace, params = {}) {
+    const query = new URLSearchParams({ workspace });
+    for (const [key, value] of Object.entries(params)) {
+        if (value?.trim())
+            query.set(key, value.trim());
+    }
+    return `/?${query.toString()}`;
+}
+export function parseWorkspaceHref(location) {
+    const query = new URLSearchParams(location.search);
+    const hash = location.hash.startsWith("#") ? location.hash.slice(1) : location.hash;
+    const hashQuery = new URLSearchParams(hash);
+    const workspace = configuredWorkspace(query.get("workspace") ?? query.get("landing") ?? hashQuery.get("workspace"));
+    if (!workspace)
+        return null;
+    const read = (key) => query.get(key)?.trim() || undefined;
+    return {
+        workspace,
+        ...(read("taskId") ? { taskId: read("taskId") } : {}),
+        ...(read("dagRunId") ? { dagRunId: read("dagRunId") } : {}),
+        ...(read("fromNodeId") ? { fromNodeId: read("fromNodeId") } : {}),
+        ...(read("featureId") ? { featureId: read("featureId") } : {}),
+    };
+}

package/dist/worker/console/dag-confirmation.js

@@ -1,6 +1,7 @@
 import { createHash, randomBytes } from "node:crypto";
 import path from "node:path";
 import { readJsonIfExists, sha256Utf8, writeSecureJson, } from "./app-data.js";
+import { confirmationPayloadHash, issueHumanGateToken, verifyHumanGateToken, } from "./human-gate-token.js";
 export const ALL_CONFIRMATION_CHALLENGES = [
     "source",
     "writer-scope",
@@ -88,8 +89,15 @@ function detectBindingDrift(rec, current) {
 }
 export class DagConfirmationStore {
     appData;
-    constructor(appData) {
+    humanGateSecret;
+    constructor(appData, 
+    /**
+     * M0-B: per-process HMAC secret for human-gate tokens
+     * (BootCapabilityToken.confirmationToken). Required for prepare/confirm.
+     */
+    humanGateSecret) {
         this.appData = appData;
+        this.humanGateSecret = humanGateSecret;
     }
     async get(confirmationId) {
         const rec = await readJsonIfExists(confirmationPath(this.appData, confirmationId));
@@ -114,15 +122,28 @@ export class DagConfirmationStore {
         const now = input.now ?? new Date();
         const ttl = input.ttlMs ?? DEFAULT_CONFIRMATION_TTL_MS;
         const confirmationId = newConfirmationId();
+        const dagSha256 = hashDagBytes(input.dagBytes);
+        const expiresAt = new Date(now.getTime() + ttl).toISOString();
+        // M0-B: issue a server-signed human-gate token bound to the confirmation's
+        // payloadHash. The browser must present it at confirm; dispatch verifies
+        // the signature so a model cannot self-confirm.
+        const payloadHash = confirmationPayloadHash({
+            dagSha256,
+            sourceBindingSha256: input.sourceBindingSha256,
+            taskContractBindingCanonical: JSON.stringify(input.taskContractBinding),
+            controllerFingerprint: input.controllerFingerprint,
+            validationResultSha256: input.validationResultSha256,
+        });
+        const humanGateToken = issueHumanGateToken({ confirmationId, payloadHash, expiresAt }, this.humanGateSecret, now);
         const rec = {
             schemaVersion: 1,
             confirmationId,
             state: "prepared",
             preparedAt: now.toISOString(),
-            expiresAt: new Date(now.getTime() + ttl).toISOString(),
+            expiresAt,
             operatorSessionId: input.operatorSessionId,
             dagHandle: input.dagHandle,
-            dagSha256: hashDagBytes(input.dagBytes),
+            dagSha256,
             dagBytesPath: input.dagBytesPath,
             sourceBindingSha256: input.sourceBindingSha256,
             taskContractBinding: input.taskContractBinding,
@@ -130,6 +151,7 @@ export class DagConfirmationStore {
             validationResultSha256: input.validationResultSha256,
             confirmedWriterScopes: input.confirmedWriterScopes ?? [],
             confirmedChallenges: [],
+            humanGateToken,
             reviewPacket: input.reviewPacket,
         };
         await writeSecureJson(confirmationPath(this.appData, confirmationId), rec);
@@ -195,14 +217,25 @@ export class DagConfirmationStore {
                 confirmation: stale,
             };
         }
-        const required = new Set(ALL_CONFIRMATION_CHALLENGES);
-        for (const c of input.challenges)
-            required.delete(c);
-        if (required.size > 0) {
+        // M0-B / roadmap G03: verify the human-gate token's HMAC signature. The
+        // old fixed-string challenge set (`source`/`writer-scope`/...) was a fake
+        // gate — a model could fill those strings directly. Now the browser must
+        // present the server-signed token issued at prepare; the signature binds
+        // (confirmationId + payloadHash + expiresAt) and is verified with the
+        // per-process boot secret. A model-side call has no way to forge it.
+        const payloadHash = confirmationPayloadHash({
+            dagSha256: current.dagSha256,
+            sourceBindingSha256: current.sourceBindingSha256,
+            taskContractBindingCanonical: JSON.stringify(current.taskContractBinding),
+            controllerFingerprint: current.controllerFingerprint,
+            validationResultSha256: current.validationResultSha256,
+        });
+        const tokenCheck = verifyHumanGateToken(input.humanGateToken, { confirmationId: input.confirmationId, payloadHash }, this.humanGateSecret, input.now);
+        if (!tokenCheck.ok) {
             return {
                 ok: false,
                 code: "HUMAN_CONFIRMATION_REQUIRED",
-                message: `missing confirmation challenges: ${[...required].join(", ")}`,
+                message: `human-gate token verification failed: ${tokenCheck.code} — ${tokenCheck.message}`,
                 confirmation: rec,
             };
         }
@@ -212,6 +245,7 @@ export class DagConfirmationStore {
             state: "confirmed",
             confirmedAt: now.toISOString(),
             confirmedChallenges: [...ALL_CONFIRMATION_CHALLENGES],
+            humanGateToken: input.humanGateToken ?? rec.humanGateToken,
         };
         await writeSecureJson(confirmationPath(this.appData, rec.confirmationId), confirmed);
         return { ok: true, confirmation: confirmed };

package/dist/worker/console/human-gate-token.js

@@ -0,0 +1,130 @@
+/**
+ * Operator Chat — Human Gate confirmation token (roadmap M0-B / G03).
+ *
+ * Closes the "fake human gate" gap (roadmap §3.2 risk 1): the old
+ * confirmDagConfirmation only checked that a FIXED set of challenge strings
+ * (`source`/`writer-scope`/`verification`/`human-gates`) was present — a model
+ * could fill those in directly and self-confirm. This module issues a
+ * server-signed token bound to (confirmationId, payloadHash, expiresAt) and
+ * verifies its HMAC signature at dispatch time, so confirmation can only
+ * originate from the browser mutation gate that received the signed token.
+ *
+ * The HMAC key is the per-process boot confirmation secret
+ * (BootCapabilityToken.confirmationToken). This binds the human-gate token to
+ * the same Console boot session that the browser established via the HttpOnly
+ * cookie — a model-side tool call cannot fabricate it.
+ */
+import { createHmac, timingSafeEqual } from "node:crypto";
+/** Canonical message string covered by the signature. */
+export function canonicalTokenMessage(p) {
+    return [
+        `v1`,
+        `confirmationId=${p.confirmationId}`,
+        `payloadHash=${p.payloadHash}`,
+        `expiresAt=${p.expiresAt}`,
+    ].join("\n");
+}
+function b64url(buf) {
+    return buf.toString("base64url");
+}
+/** Issue a signed token. `secret` = BootCapabilityToken.confirmationToken. */
+export function issueHumanGateToken(payload, secret, now = new Date()) {
+    const sig = createHmac("sha256", secret).update(canonicalTokenMessage(payload)).digest();
+    return {
+        ...payload,
+        signature: b64url(sig),
+        issuedAt: now.toISOString(),
+    };
+}
+/**
+ * Verify a presented token. Checks signature, expiry, and that the token is
+ * bound to the given confirmationId + current payloadHash. Constant-time
+ * signature compare. Returns a typed failure (no thrown secrets).
+ */
+export function verifyHumanGateToken(presented, expected, secret, now = new Date()) {
+    if (!presented || typeof presented !== "object") {
+        return { ok: false, code: "MISSING_TOKEN", message: "no human-gate token presented" };
+    }
+    if (presented.confirmationId !== expected.confirmationId) {
+        return {
+            ok: false,
+            code: "CONFIRMATION_MISMATCH",
+            message: "token is bound to a different confirmationId",
+        };
+    }
+    if (presented.payloadHash !== expected.payloadHash) {
+        return {
+            ok: false,
+            code: "PAYLOAD_MISMATCH",
+            message: "token payloadHash does not match the current confirmation bindings",
+        };
+    }
+    const expectedSig = createHmac("sha256", secret)
+        .update(canonicalTokenMessage(presented))
+        .digest();
+    let presentedSig;
+    try {
+        presentedSig = Buffer.from(presented.signature, "base64url");
+    }
+    catch {
+        return { ok: false, code: "INVALID_SIGNATURE", message: "signature is not valid base64url" };
+    }
+    if (presentedSig.length !== expectedSig.length ||
+        !timingSafeEqual(presentedSig, expectedSig)) {
+        return { ok: false, code: "INVALID_SIGNATURE", message: "signature verification failed" };
+    }
+    if (Date.parse(presented.expiresAt) <= now.getTime()) {
+        return { ok: false, code: "EXPIRED", message: "token has expired" };
+    }
+    return { ok: true, token: presented };
+}
+/**
+ * Compute the payloadHash for a confirmation receipt: SHA-256 over the binding
+ * snapshot (dagSha256 + sourceBindingSha256 + taskContractBinding canonical +
+ * controllerFingerprint + validationResultSha256). Changing any binding
+ * invalidates the token (defense against drift-then-confirm).
+ */
+import { createHash } from "node:crypto";
+import { sha256Utf8 } from "./app-data.js";
+export function confirmationPayloadHash(b) {
+    const canonical = [
+        `dag=${b.dagSha256}`,
+        `source=${b.sourceBindingSha256}`,
+        `contract=${sha256Utf8(b.taskContractBindingCanonical)}`,
+        `controller=${b.controllerFingerprint}`,
+        `validation=${b.validationResultSha256}`,
+    ].join("\n");
+    return createHash("sha256").update(canonical).digest("hex");
+}
+/** Stable contract-apply binding; revision and observed hash prevent drift-then-confirm. */
+export function contractApplyPayloadHash(b) {
+    const canonical = [
+        "v1-contract-apply",
+        `taskId=${b.taskId}`,
+        `revision=${b.revision}`,
+        `canonicalHash=${b.canonicalHash}`,
+        `draftSha256=${b.draftSha256}`,
+        `expectedObservedHash=${b.expectedObservedHash}`,
+    ].join("\n");
+    return createHash("sha256").update(canonical).digest("hex");
+}
+/** Stable mutation-gate binding; params are canonical-JSON with sorted keys. */
+export function mutationGatePayloadHash(b) {
+    const paramsCanonical = stableJson(b.actionParams);
+    const canonical = [
+        "v1-mutation-gate",
+        `action=${b.action}`,
+        `operatorSessionId=${b.operatorSessionId}`,
+        `actionParams=${paramsCanonical}`,
+    ].join("\n");
+    return createHash("sha256").update(canonical).digest("hex");
+}
+function stableJson(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map((entry) => stableJson(entry)).join(",")}]`;
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    return `{${keys.map((key) => `${JSON.stringify(key)}:${stableJson(obj[key])}`).join(",")}}`;
+}