@litfamily/lithermes 1.0.0

package/src/lib/modelPrompt.js

@@ -0,0 +1,201 @@
+const readline = require("node:readline");
+const { parseDocument } = require("yaml");
+const mark = require("./litMark");
+const { PROVIDER_IDS, ROUTE_CATALOG, managedRequest, missingCredentialWarning } = require("./modelRoutePolicy");
+
+// Installer prompts and frame per plans/references/installer-choice-contract.md.
+// Numbered zero-based readline menus, default in brackets, no TUI dependency.
+
+function paint(enabled, rgb, text) {
+  return enabled ? `\x1b[38;2;${rgb}m${text}\x1b[39m` : text;
+}
+
+function renderInstallBanner({ version = "current", color = false, env = process.env, stream = process.stdout } = {}) {
+  const rows = mark.lockup(`lithermes v${version}`, mark.banner);
+  return mark.render(rows, { env, stream, mode: color ? mark.colorMode({ env, stream }) : "none" }).join("\n");
+}
+
+function providerLabel(id) {
+  return `${ROUTE_CATALOG[id].label.padEnd(30)} (${id})`;
+}
+
+function rowLabel(row) {
+  return `${row.model.padEnd(24)} · ${row.effort.padEnd(6)} — ${row.note}`;
+}
+
+// readline discards 'line' events that arrive while no question is pending,
+// which loses piped answers between menus — so lines are queued here instead.
+function createLineReader(rl) {
+  const queued = [];
+  let waiter = null;
+  let closed = false;
+  rl.on("line", (line) => {
+    if (waiter) {
+      const resolve = waiter;
+      waiter = null;
+      resolve({ line });
+    } else {
+      queued.push(line);
+    }
+  });
+  rl.on("close", () => {
+    closed = true;
+    if (waiter) {
+      const resolve = waiter;
+      waiter = null;
+      resolve({ closed: true });
+    }
+  });
+  return () => {
+    if (queued.length) return Promise.resolve({ line: queued.shift() });
+    if (closed) return Promise.resolve({ closed: true });
+    return new Promise((resolve) => { waiter = resolve; });
+  };
+}
+
+async function menu(nextLine, output, title, items, defaultIndex) {
+  const max = items.length - 1;
+  output.write(`${title}\n`);
+  items.forEach((item, index) => output.write(`   ${index}. ${item}\n`));
+  for (;;) {
+    output.write(`Select 0-${max} [${defaultIndex}]: `);
+    const answer = await nextLine();
+    if (answer.closed) return defaultIndex;
+    const trimmed = answer.line.trim();
+    if (!trimmed) return defaultIndex;
+    const index = /^\d+$/.test(trimmed) ? Number(trimmed) : NaN;
+    if (Number.isInteger(index) && index >= 0 && index <= max) return index;
+    output.write(`Please answer 0-${max}.\n`);
+  }
+}
+
+function rowIndex(rows, preset) {
+  const index = rows.findIndex((row) => row.model === preset.model && row.effort === preset.effort);
+  return index === -1 ? 0 : index;
+}
+
+function routeFromConfig(text) {
+  if (!String(text || "").trim()) return managedRequest();
+  try {
+    const document = parseDocument(String(text), { strict: true, uniqueKeys: true });
+    if (document.errors.length) return managedRequest();
+    return managedRequest({
+      childEffort: document.getIn(["delegation", "reasoning_effort"]),
+      childModel: document.getIn(["delegation", "model"]),
+      childProvider: document.getIn(["delegation", "provider"]),
+      effort: document.getIn(["agent", "reasoning_effort"]),
+      model: document.getIn(["model", "default"]),
+      provider: document.getIn(["model", "provider"]),
+    });
+  } catch {
+    return managedRequest();
+  }
+}
+
+// Provider → lead model+effort → helper provider → helper model+effort.
+// Falls back to the shipped default route if the input closes before an answer.
+async function runMenus(nextLine, output, preset = managedRequest()) {
+  try {
+    const providerDefaultIndex = Math.max(0, PROVIDER_IDS.indexOf(preset.provider));
+    const providerIndex = await menu(
+      nextLine,
+      output,
+      "Choose the provider for LitHermes agents.",
+      PROVIDER_IDS.map(providerLabel),
+      providerDefaultIndex,
+    );
+    const provider = PROVIDER_IDS[providerIndex];
+    const leadRows = ROUTE_CATALOG[provider].rows;
+    const leadPreset = provider === preset.provider ? preset : ROUTE_CATALOG[provider].lead;
+    const leadIndex = await menu(
+      nextLine,
+      output,
+      "Choose the LEAD model (plans and reviews).",
+      leadRows.map(rowLabel),
+      rowIndex(leadRows, leadPreset),
+    );
+    const childProviderDefault = provider === preset.provider ? preset.childProvider : provider;
+    const childProviderDefaultIndex = Math.max(0, PROVIDER_IDS.indexOf(childProviderDefault));
+    const childProviderIndex = await menu(
+      nextLine,
+      output,
+      "Choose the provider for HELPER agents (delegated workers).",
+      PROVIDER_IDS.map(providerLabel),
+      childProviderDefaultIndex,
+    );
+    const childProvider = PROVIDER_IDS[childProviderIndex];
+    const helperRows = ROUTE_CATALOG[childProvider].rows;
+    const helperPreset = provider === preset.provider && childProvider === preset.childProvider
+      ? preset
+      : ROUTE_CATALOG[childProvider].helper;
+    const helperIndex = await menu(
+      nextLine,
+      output,
+      "Choose the HELPER model (delegated workers).",
+      helperRows.map(rowLabel),
+      rowIndex(helperRows, helperPreset === preset
+        ? { model: preset.childModel, effort: preset.childEffort }
+        : helperPreset),
+    );
+    return managedRequest({
+      childEffort: helperRows[helperIndex].effort,
+      childModel: helperRows[helperIndex].model,
+      childProvider,
+      effort: leadRows[leadIndex].effort,
+      model: leadRows[leadIndex].model,
+      provider,
+    });
+  } catch {
+    return managedRequest();
+  }
+}
+
+async function promptModelRoute({ input = process.stdin, output = process.stdout } = {}) {
+  const rl = readline.createInterface({ input, terminal: false });
+  try {
+    return await runMenus(createLineReader(rl), output);
+  } finally {
+    rl.close();
+  }
+}
+
+// One readline session covering the menus, the summary card, and the Enter
+// confirmation, so a queued keystroke cannot be lost between two interfaces.
+async function promptModelRouteSession({ input = process.stdin, output = process.stdout, env = process.env, configPath, preset = managedRequest() } = {}) {
+  const rl = readline.createInterface({ input, terminal: false });
+  const nextLine = createLineReader(rl);
+  try {
+    output.write(`Model route: currently ${preset.model} · ${preset.effort}\n`);
+    output.write("   0. keep current            (recommended)\n");
+    const route = await runMenus(nextLine, output, preset);
+    output.write(`${renderModelRouteCard(route, { configPath, env })}\n`);
+    const answer = await nextLine();
+    return { confirmed: !answer.closed, route };
+  } finally {
+    rl.close();
+  }
+}
+
+function renderModelRouteCard(route, { configPath, env = process.env } = {}) {
+  const sameProvider = route.childProvider === route.provider;
+  const helpers = `${sameProvider ? "" : `${route.childProvider} / `}${route.childModel} · ${route.childEffort}`;
+  const warning = missingCredentialWarning(route, env);
+  return [
+    "╭─ MODEL ROUTE",
+    `│ Provider   ${route.provider}`,
+    `│ Lead       ${route.model} · ${route.effort}`,
+    `│ Helpers    ${helpers}`,
+    `│ Writes     ${configPath}  (managed keys only)`,
+    ...(warning ? [`│ Warning    ${warning}`] : []),
+    "╰─ Enter to continue · Ctrl-C to abort (nothing written yet)",
+  ].join("\n");
+}
+
+module.exports = {
+  missingCredentialWarning,
+  promptModelRoute,
+  promptModelRouteSession,
+  routeFromConfig,
+  renderInstallBanner,
+  renderModelRouteCard,
+};

package/src/lib/modelRoutePolicy.js

@@ -0,0 +1,379 @@
+const ASTRA_MODEL = "gpt-6-astra";
+const ASTRA_EFFORTS = new Set(["low", "medium", "high", "xhigh", "max"]);
+const PARENT_MODEL = ASTRA_MODEL;
+const PARENT_EFFORT = "xhigh";
+const CHILD_MODEL = "gpt-5.6-luna";
+const CHILD_EFFORT = "max";
+const LUNA_EFFORTS = new Set(["high", "max"]);
+const TERRA_MODEL = "gpt-5.6-terra";
+const TERRA_EFFORTS = new Set(["high", "xhigh", "max"]);
+const CHILD_TRANSPORT_KEYS = ["provider", "base_url", "api_mode"];
+const { OPENAI_PROVIDER: OPENAI_PROVIDER_ID } = require("./modelConfigBoundary");
+const XAI_PROVIDER_ID = "xai";
+// Installer choice catalog (plans/references/installer-choice-contract.md, LitHermes row).
+// OpenAI rows: Astra exposes exactly the five Responses efforts; the existing Sol,
+// Luna, and general GPT-5.6 rows remain below it and Luna+xhigh is never listed. xAI rows: the
+// reasoning-capable models of the Hermes 0.19 static xAI catalog
+// (hermes_cli/models.py `_XAI_STATIC_FALLBACK`), newest first, with the Hermes
+// reasoning_effort vocabulary (hermes_cli/config.py delegation.reasoning_effort).
+const ROUTE_CATALOG = {
+  [OPENAI_PROVIDER_ID]: {
+    credentialEnv: null,
+    label: "OpenAI OAuth Responses (Astra + GPT-5.6)",
+    rows: [
+      ...["low", "medium", "high", "xhigh", "max"].map((effort) => ({
+        effort,
+        model: ASTRA_MODEL,
+        note: effort === "max"
+          ? "deepest Astra reasoning"
+          : effort === PARENT_EFFORT
+            ? "recommended lead"
+            : "Astra Responses effort",
+      })),
+      { effort: PARENT_EFFORT, model: "gpt-5.6-sol", note: "existing Sol lead route" },
+      { effort: CHILD_EFFORT, model: CHILD_MODEL, note: "balanced (recommended helper)" },
+      { effort: "high", model: CHILD_MODEL, note: "balanced, lighter effort" },
+      { effort: "high", model: "gpt-5.6", note: "general model" },
+    ],
+    lead: { effort: PARENT_EFFORT, model: PARENT_MODEL },
+    helper: { effort: CHILD_EFFORT, model: CHILD_MODEL },
+  },
+  [XAI_PROVIDER_ID]: {
+    credentialEnv: "XAI_API_KEY",
+    label: "xAI Grok",
+    rows: [
+      { effort: "high", model: "grok-build-0.1", note: "newest coding model (recommended lead)" },
+      { effort: "high", model: "grok-4.5", note: "flagship reasoning" },
+      { effort: "high", model: "grok-4.3", note: "fast reasoning (recommended helper)" },
+      { effort: "high", model: "grok-4.20-0309-reasoning", note: "previous reasoning generation" },
+    ],
+    lead: { effort: "high", model: "grok-build-0.1" },
+    helper: { effort: "high", model: "grok-4.3" },
+  },
+};
+const PROVIDER_IDS = Object.keys(ROUTE_CATALOG);
+const MANAGED_PROVIDER_MODELS = Object.fromEntries(
+  PROVIDER_IDS.map((id) => [id, new Set(ROUTE_CATALOG[id].rows.map((row) => row.model))]),
+);
+const MANAGED_PROVIDERS = new Set(PROVIDER_IDS);
+const UNSAFE_ROUTE_CODE = "LITHERMES_UNSAFE_MODEL_ROUTE";
+const REVIEWER_ROUTE_NAME = String.fromCharCode(109, 111, 109, 117, 115);
+
+function inspectEffectiveRouteSafety(document, expectedProvider) {
+  const transportReason = customChildTransportReason(document);
+  const parentProvider = document.getIn(["model", "provider"]);
+  const parentModel = document.getIn(["model", "default"]);
+  const parentEffort = document.getIn(["agent", "reasoning_effort"]);
+  const childModel = document.getIn(["delegation", "model"]);
+  const childEffort = document.getIn(["delegation", "reasoning_effort"]);
+  const routes = [
+    {
+      effort: parentEffort,
+      model: parentModel,
+      provider: parentProvider,
+      route: "parent",
+    },
+    {
+      effort: childEffort === undefined || childEffort === null || childEffort === "" ? parentEffort : childEffort,
+      model: childModel === undefined || childModel === null || childModel === "" ? parentModel : childModel,
+      provider: document.getIn(["delegation", "provider"]) || parentProvider,
+      route: "global_child",
+    },
+  ];
+  const managedRoutes = routes.filter((route) => route.provider === expectedProvider);
+  for (const route of managedRoutes) {
+    if (transportReason && route.route === "global_child") continue;
+    if (route.model === ASTRA_MODEL && !ASTRA_EFFORTS.has(route.effort)) {
+      return {
+        classificationClass: "astra_effort_unsupported",
+        code: UNSAFE_ROUTE_CODE,
+        observedSource: `${route.route} model, effort, and provider config`,
+        reason: `${route.route} Astra effort is unsupported or missing; choose one of: ${[...ASTRA_EFFORTS].join(", ")}`,
+        route: route.route,
+        status: "blocked",
+      };
+    }
+    if (route.model === CHILD_MODEL && route.effort === "xhigh") {
+      return {
+        classificationClass: "conflicting_luna_xhigh",
+        code: UNSAFE_ROUTE_CODE,
+        observedSource: `${route.route} model, effort, and provider config`,
+        reason: `${route.route} Luna xhigh is a forbidden pair (Luna runs at high or max)`,
+        route: route.route,
+        status: "blocked",
+      };
+    }
+    if (route.model === CHILD_MODEL && !LUNA_EFFORTS.has(route.effort)) {
+      return {
+        classificationClass: "luna_effort_below_high",
+        code: UNSAFE_ROUTE_CODE,
+        observedSource: `${route.route} model, effort, and provider config`,
+        reason: `${route.route} Luna effort is below high or missing`,
+        route: route.route,
+        status: "blocked",
+      };
+    }
+    if (route.model === TERRA_MODEL && !TERRA_EFFORTS.has(route.effort)) {
+      return {
+        classificationClass: "terra_effort_below_high",
+        code: UNSAFE_ROUTE_CODE,
+        observedSource: `${route.route} model, effort, and provider config`,
+        reason: `${route.route} TERRA effort is below high or missing`,
+        route: route.route,
+        status: "blocked",
+      };
+    }
+  }
+  if (transportReason) {
+    return {
+      observedSource: "global delegation transport config",
+      reason: `${transportReason}; managed child route remains unapplied`,
+      status: "not_applicable",
+    };
+  }
+  if (!managedRoutes.length) {
+    return {
+      observedSource: "model and global delegation provider config",
+      reason: "custom provider remains outside the managed OpenAI route policy",
+      status: "not_applicable",
+    };
+  }
+  return {
+    observedSource: "parent and global delegation model policy",
+    reason: "no effective under-effort Luna or TERRA route is configured",
+    status: "safe",
+  };
+}
+
+function catalogFor(provider, role) {
+  const catalog = ROUTE_CATALOG[provider];
+  if (!catalog) {
+    throw new Error(`unknown provider '${provider}' for the ${role} route; choose one of: ${PROVIDER_IDS.join(", ")}`);
+  }
+  return catalog;
+}
+
+function resolveRow(provider, role, model, effort) {
+  const catalog = catalogFor(provider, role);
+  const preset = role === "lead" ? catalog.lead : catalog.helper;
+  if (model === "" || effort === "") {
+    throw new Error(`${role} model/effort flags require a value; omit the flag to use the default route`);
+  }
+  const hasModel = model !== undefined;
+  const hasEffort = effort !== undefined;
+  const resolvedModel = hasModel ? String(model) : preset.model;
+  if (resolvedModel === CHILD_MODEL && hasEffort && effort === "xhigh") {
+    throw new Error(`${role} route ${CHILD_MODEL} xhigh is a forbidden pair; Luna runs at high or max`);
+  }
+  const rowsForModel = catalog.rows.filter((row) => row.model === resolvedModel);
+  if (!rowsForModel.length) {
+    const known = PROVIDER_IDS.some((id) => ROUTE_CATALOG[id].rows.some((row) => row.model === resolvedModel));
+    throw new Error(known
+      ? `${role} model ${resolvedModel} is not offered for provider ${provider}`
+      : `unknown model '${resolvedModel}' for the ${role} route; choose one of: ${catalog.rows.map((row) => row.model).join(", ")}`);
+  }
+  // An explicitly selected model keeps that model's cataloged preset effort
+  // when no effort flag is supplied. This matters for Astra: its recommended
+  // lead row is xhigh, while its catalog is intentionally listed low-first.
+  const modelDefault = rowsForModel.find((row) => row.effort === preset.effort)?.effort ?? rowsForModel[0].effort;
+  const resolvedEffort = hasEffort ? String(effort) : (hasModel ? modelDefault : preset.effort);
+  if (!rowsForModel.some((row) => row.effort === resolvedEffort)) {
+    throw new Error(`${role} effort ${resolvedEffort} is not offered for ${resolvedModel}; choose one of: ${rowsForModel.map((row) => row.effort).join(", ")}`);
+  }
+  return { effort: resolvedEffort, model: resolvedModel };
+}
+
+// Resolves installer flags (or prompt answers) to one managed route. Omitted
+// fields fall back to today's shipped route: openai Astra xhigh lead + Luna max child.
+function managedRequest(options = {}) {
+  const provider = options.provider === undefined || options.provider === "" ? OPENAI_PROVIDER_ID : String(options.provider);
+  const childProvider = options.childProvider === undefined || options.childProvider === ""
+    ? provider
+    : String(options.childProvider);
+  const lead = resolveRow(provider, "lead", options.model, options.effort);
+  const child = resolveRow(childProvider, "child", options.childModel, options.childEffort);
+  return {
+    childEffort: child.effort,
+    childModel: child.model,
+    childProvider,
+    effort: lead.effort,
+    model: lead.model,
+    provider,
+  };
+}
+
+function applyManagedRoute(document, route = managedRequest()) {
+  document.setIn(["model", "provider"], route.provider);
+  document.setIn(["model", "default"], route.model);
+  document.setIn(["agent", "reasoning_effort"], route.effort);
+  document.setIn(["delegation", "provider"], route.childProvider);
+  document.setIn(["delegation", "model"], route.childModel);
+  document.setIn(["delegation", "reasoning_effort"], route.childEffort);
+}
+
+function customChildTransportReason(document) {
+  const configuredKeys = CHILD_TRANSPORT_KEYS.filter((key) => {
+    const value = document.getIn(["delegation", key]);
+    if (value === undefined || value === null || value === "") return false;
+    return !(key === "provider" && MANAGED_PROVIDERS.has(value));
+  });
+  return configuredKeys.length
+    ? `custom global child transport fields are preserved (${configuredKeys.join(", ")})`
+    : null;
+}
+
+function inspectManagedRoute(document, expectedProvider, route = managedRequest()) {
+  const transportReason = customChildTransportReason(document);
+  if (transportReason) {
+    return {
+      status: "unavailable",
+      reason: transportReason,
+      observedSource: "global delegation transport config",
+    };
+  }
+  const parentProvider = document.getIn(["model", "provider"]);
+  const parentModel = document.getIn(["model", "default"]);
+  const parentEffort = document.getIn(["agent", "reasoning_effort"]);
+  const childModel = document.getIn(["delegation", "model"]);
+  const childEffort = document.getIn(["delegation", "reasoning_effort"]);
+  const childProvider = document.getIn(["delegation", "provider"]) || parentProvider;
+  const configured = parentProvider === route.provider
+    && parentModel === route.model
+    && parentEffort === route.effort
+    && childProvider === route.childProvider
+    && childModel === route.childModel
+    && childEffort === route.childEffort;
+  const legacyConfigured = parentProvider === expectedProvider
+    && parentModel === "gpt-5.6-luna"
+    && parentEffort === "max"
+    && childModel === CHILD_MODEL
+    && LUNA_EFFORTS.has(childEffort);
+  if (!configured && !legacyConfigured) {
+    return {
+      status: "unavailable",
+      reason: `exact lead ${route.model} ${route.effort} and global child ${route.childModel} ${route.childEffort} route is not configured`,
+      observedSource: "model, agent, and global delegation config",
+    };
+  }
+  return {
+    status: "configured",
+    reason: "global child route is configured; execution receipt required before claiming it ran",
+    observedSource: "model, agent, and global delegation config",
+    childEffort,
+    childModel,
+    childProvider,
+    executionProof: "unavailable",
+    parentEffort,
+    parentModel,
+    providerIsInherited: childProvider === parentProvider,
+  };
+}
+
+function inspectLeadRoute(document, expectedProvider, route = managedRequest()) {
+  const configured = document.getIn(["model", "provider"]) === route.provider
+    && document.getIn(["model", "default"]) === route.model
+    && document.getIn(["agent", "reasoning_effort"]) === route.effort;
+  return configured
+    ? {
+      status: "configured",
+      reason: `lead route is configured for the chosen ${route.provider} ${route.model} ${route.effort} surface`,
+      observedSource: "model.provider, model.default, and agent.reasoning_effort",
+      effort: route.effort,
+      model: route.model,
+      provider: route.provider,
+    }
+    : {
+      status: "unavailable",
+      reason: `chosen lead ${route.model} ${route.effort} route is not configured`,
+      observedSource: "model.provider, model.default, and agent.reasoning_effort",
+    };
+}
+
+function inspectOrdinaryWorkerRoute(document, expectedProvider, route = managedRequest()) {
+  const transportReason = customChildTransportReason(document);
+  if (transportReason) {
+    return {
+      status: "unavailable",
+      reason: `${transportReason}; managed child route remains unapplied`,
+      observedSource: "global delegation transport config",
+    };
+  }
+  const childProvider = document.getIn(["delegation", "provider"]) || document.getIn(["model", "provider"]);
+  const configured = childProvider === route.childProvider
+    && document.getIn(["delegation", "model"]) === route.childModel
+    && document.getIn(["delegation", "reasoning_effort"]) === route.childEffort;
+  return configured
+    ? {
+      status: "configured",
+      reason: "ordinary workers use the chosen global child route",
+      observedSource: "delegation.provider (or model.provider) and global delegation model/effort config",
+      effort: route.childEffort,
+      model: route.childModel,
+      provider: route.childProvider,
+    }
+    : {
+      status: "unavailable",
+      reason: `chosen global child ${route.childModel} ${route.childEffort} route is not configured`,
+      observedSource: "model.provider and global delegation model/effort config",
+    };
+}
+
+// A provider whose credential variable is absent still gets written (Task 6
+// brief, decision 2); callers print this warning naming the variable to set.
+function missingCredentialWarning(route, env = process.env) {
+  const missing = [];
+  for (const provider of [route.provider, route.childProvider]) {
+    const variable = ROUTE_CATALOG[provider]?.credentialEnv;
+    if (variable && !env[variable] && !missing.includes(variable)) missing.push(variable);
+  }
+  if (!missing.length) return null;
+  return `${missing.join(", ")} is not set; export it before starting Hermes (config is still written)`;
+}
+
+function unavailableReviewerRoutes() {
+  return {
+    status: "unavailable",
+    reason: `Hermes exposes no per-subagent model override for ${REVIEWER_ROUTE_NAME} or litwork-reviewer`,
+    observedSource: "Hermes delegate_task and global delegation config",
+  };
+}
+
+function unavailableReviewerRouteName() {
+  return REVIEWER_ROUTE_NAME;
+}
+
+function unavailableTuiRouteVisibility() {
+  return {
+    status: "unavailable",
+    reason: "Hermes exposes no per-subagent model override or TUI route visibility surface",
+    observedSource: "Hermes TUI and delegation surfaces",
+  };
+}
+
+function formatManagedRoute(route) {
+  return route.status === "configured"
+    ? `configured (${route.childModel}, effort ${route.childEffort}, provider ${route.providerIsInherited ? "inherited" : route.childProvider}; execution receipt required)`
+    : `${route.status} (${route.reason})`;
+}
+
+module.exports = {
+  ASTRA_EFFORTS,
+  ASTRA_MODEL,
+  MANAGED_PROVIDER_MODELS,
+  OPENAI_PROVIDER_ID,
+  PROVIDER_IDS,
+  ROUTE_CATALOG,
+  XAI_PROVIDER_ID,
+  applyManagedRoute,
+  customChildTransportReason,
+  formatManagedRoute,
+  inspectEffectiveRouteSafety,
+  inspectLeadRoute,
+  inspectManagedRoute,
+  inspectOrdinaryWorkerRoute,
+  managedRequest,
+  missingCredentialWarning,
+  unavailableReviewerRoutes,
+  unavailableReviewerRouteName,
+  unavailableTuiRouteVisibility,
+};