arkgate 2.12.0 → 3.0.0

package/bin/ark-check.mjs

@@ -33,6 +33,7 @@ import {
   loadTypeScript,
   detectSkillGaps,
   detectCodexHomeGap,
+  detectActiveAgentHost,
   missingGates,
   staleRunnerGateFiles,
   brokenMcpGateFiles,
@@ -41,6 +42,7 @@ import {
   checkArchitectureScriptSnippet,
   arkCheckCommand,
   arkPackageVersion,
+  compactRouterHost,
   REQUIRED_GATE_FILES,
   codexPromptsDir,
   detectWritePathCapabilities,
@@ -56,6 +58,7 @@ import {
   reportsDir,
   readJsonSafe,
 } from './lib/html-report.mjs';
+import { shouldOpenHtmlReport, openHtmlInBrowser } from './lib/open-html.mjs';
 import {
   computeCoverage,
   runCoverage,
@@ -81,6 +84,8 @@ import {
 import {
   ARCHITECTURE_PRESETS,
 } from './lib/presets.mjs';
+import { loadArkConfigContract, parseArkConfigJson } from './lib/config-contract.mjs';
+import { createAdapterResult } from './lib/adapter-contract.mjs';
 
 import {
   collectGovernedFiles,
@@ -91,6 +96,7 @@ import {
   configWarning,
 } from './lib/config-warnings.mjs';
 import { runArchitectureScan } from './lib/architecture-scan.mjs';
+import { validateHardWriteRequest } from './lib/enforcement-profiles.mjs';
 
 
 function parseArgs(argv) {
@@ -101,11 +107,12 @@ function parseArgs(argv) {
     printConfig: undefined,
     tsconfig: undefined,
     json: false,
-    strict: false,
     strictConfig: false,
     requireGates: false,
+    requireWriteHook: undefined,
     init: false,
     installAgentGates: false,
+    compact: false,
     tools: undefined,
     force: false,
     skillsOnly: false,
@@ -122,6 +129,8 @@ function parseArgs(argv) {
     applyPolicyPack: undefined,
     watch: false,
     beginner: false,
+    openReport: false,
+    noOpenReport: false,
     version: false,
     help: false,
   };
@@ -135,16 +144,19 @@ function parseArgs(argv) {
   for (let i = 2; i < argv.length; i += 1) {
     const arg = argv[i];
     if (arg === '--json') args.json = true;
-    else if (arg === '--strict') {
-      args.strict = true;
+    else if (arg === '--strict' || arg === '--strict-merge') {
       args.strictConfig = true;
       args.requireGates = true;
     }
     else if (arg === '--strict-config') args.strictConfig = true;
     else if (arg === '--require-gates') args.requireGates = true;
+    else if (arg === '--require-write-hook') {
+      args.requireWriteHook = requireValue(arg, i++).trim().toLowerCase();
+    }
     else if (arg === '--init') args.init = true;
     else if (arg === '--preset') args.preset = requireValue(arg, i++);
     else if (arg === '--install-agent-gates') args.installAgentGates = true;
+    else if (arg === '--compact') args.compact = true;
     else if (arg === '--tools') {
       // Consume the next arg only when it isn't another flag (same rule as --baseline),
       // so `--tools --force` can't silently eat --force as a "tool name".
@@ -183,6 +195,8 @@ function parseArgs(argv) {
     }
     else if (arg === '--reset-origin') args.resetOrigin = true;
     else if (arg === '--no-archive') args.noArchive = true;
+    else if (arg === '--open') args.openReport = true;
+    else if (arg === '--no-open') args.noOpenReport = true;
     else if (arg === '--baseline' || arg === '--update-baseline') {
       if (arg === '--update-baseline') args.updateBaseline = true;
       // optional path value: consume the next arg only when it isn't another flag
@@ -214,7 +228,7 @@ function usage() {
   return [
     'Usage: arkgate-check | ark-check  (identical bins; product name ArkGate)',
     '       ark-check --version',
-    '       ark-check --root <project> --config <ark.config.json> [--manifest <ark.manifest.json>] [--tsconfig <tsconfig.json>] [--strict | --strict-config] [--require-gates] [--json] [--baseline [file]] [--report [file.html]] [--no-cache]',
+    '       ark-check --root <project> --config <ark.config.json> [--manifest <ark.manifest.json>] [--tsconfig <tsconfig.json>] [--strict-merge | --strict | --strict-config] [--require-gates] [--require-write-hook <host>] [--json] [--baseline [file]] [--report [file.html]] [--no-cache]',
     '       ark-check --coverage [--json]          per-layer file counts + full unclassified list (report only, exit 0)',
     '       ark-check --plan [--json]              classified remediation plan (mechanical-safe / judgment / deferred) + goal; report only',
     '       ark-check --recommend [--json] [--write-plan]  application-shape plan; --write-plan emits ark-adoption-plan.json',
@@ -224,10 +238,11 @@ function usage() {
     '       ark-check --adopt-contract [--write]   expand include + UI patterns from ungoverned dirs (contract adopt)',
     '       ark-check --ratchet-cores              when raw graph is green (0 violations; baseline ignored), set optional:false on populated cores only (writes ark.config.json)',
     '       ark-check --watch                      re-run the check when governed files change (debounced)',
-    '       ark-check --report [file.html] [--beginner] [--reset-origin] [--no-archive]',
+    '       ark-check --report [file.html] [--beginner] [--reset-origin] [--no-archive] [--open|--no-open]',
     '           HTML report + snapshots under .ark/reports/ (origin once, latest each run, history JSON)',
+    '           Best-effort open in browser (local TTY). No-op if open fails. --no-open / ARK_NO_OPEN_REPORT=1 to skip; --open forces open.',
     '       ark-check --init [--preset hexagonal|layered|feature-sliced|monorepo|ui-surface|vertical-slice|ddd-bounded-contexts|clean-architecture|onion-architecture] [--force]',
-    '       ark-check --install-agent-gates [--tools claude,cursor,codex,grok] [--skills-only] [--codex-home] [--force]',
+    '       ark-check --install-agent-gates [--tools claude,cursor,codex,grok] [--require-write-hook <host>] [--skills-only] [--codex-home] [--force]',
     '       ark-check --update-baseline [file]     freeze current violations (default .ark-baseline.json)',
     '       ark-check --print-config eleven-layer',
     '',
@@ -267,8 +282,12 @@ function usage() {
     '',
     'Config warnings are advisory by default and are included in JSON output.',
     'Use --strict-config to make config warnings fail the check.',
-    'Use --strict for the fail-closed CI profile: --strict-config + --require-gates',
-    'plus the security diagnostics surfaced by doctor.',
+    'Use --strict-merge for the fail-closed CI profile: --strict-config + --require-gates',
+    'plus the security diagnostics surfaced by doctor. --strict is a compatibility alias.',
+    'This merge profile never depends on an editor/agent hook.',
+    'Add --require-write-hook claude|grok to validate a hard local write boundary for that',
+    'specific host. Cursor and Codex expose advisory MCP tools plus the shared CI check;',
+    'merge blocking requires repository policy to make that status required.',
     '',
     '--require-gates fails the check when AGENTS.md, .mcp.json, or the generated CI',
     'workflow is missing, so "installed but never configured" is a red CI. Combine it',
@@ -276,7 +295,8 @@ function usage() {
     '',
     '--install-agent-gates writes AGENTS.md, .mcp.json, and the CI workflow for every',
     'project, plus tool-specific templates. Known tools: claude, cursor, codex, grok',
-    '(full MCP/hook gates) and windsurf, cline, copilot, kiro, roo, continue, gemini',
+    '(Claude/Grok hard-write hooks; Cursor/Codex advisory MCP; shared CI check for all) and',
+    'windsurf, cline, copilot, kiro, roo, continue, gemini',
     '(instruction-tier rule files derived from the same contract).',
     'It also installs the /ark-* skills shipped in templates/skills/ into each',
     'detected tool\'s command location (.claude/skills/, .cursor/commands/,',
@@ -290,7 +310,7 @@ function usage() {
     'Pass --tools to pick which tool configs to write; otherwise they are auto-detected',
     'from their config directories (.claude/, .cursor/, .codex/, .grok/, .windsurf/,',
     '.clinerules/, .kiro/, .roo/, .continue/, .gemini/; copilot is explicit-only).',
-    'claude+cursor+codex are written when nothing is detected.',
+    'claude+cursor+codex+grok are written when nothing is detected.',
     '',
     'Generate a starter 11-layer config:',
     '  ark-check --print-config eleven-layer > ark.config.json',
@@ -305,25 +325,12 @@ function readConfig(root, configPath) {
     ? configPath
     : path.join(root, configPath);
   if (!fs.existsSync(fullPath)) {
-    return {
-      include: ['src'],
-      layers: [],
-      rules: DEFAULT_RULES,
-    };
+    return loadArkConfigContract(
+      { include: ['src'], layers: [], rules: DEFAULT_RULES },
+      fullPath
+    ).config;
   }
-  const raw = JSON.parse(fs.readFileSync(fullPath, 'utf8'));
-  return {
-    include: raw.include ?? ['src'],
-    layers: raw.layers ?? [],
-    rules: raw.rules ?? DEFAULT_RULES,
-    ...(raw.exclude ? { exclude: raw.exclude } : {}),
-    ...(raw.excludeGenerated !== undefined ? { excludeGenerated: raw.excludeGenerated } : {}),
-    ...(raw.cyclePolicy ? { cyclePolicy: raw.cyclePolicy } : {}),
-    ...(raw.dynamicImportAllowlist
-      ? { dynamicImportAllowlist: raw.dynamicImportAllowlist }
-      : {}),
-    ...(raw.safety ? { safety: raw.safety } : {}),
-  };
+  return parseArkConfigJson(fs.readFileSync(fullPath, 'utf8'), fullPath).config;
 }
 
 /**
@@ -976,16 +983,41 @@ async function main() {
     return;
   }
 
-  if (args.requireGates) {
-    const missing = missingGates(args.root);
-    if (args.strict && !detectWritePathCapabilities(args.root).hookPresent) {
-      missing.push('PreToolUse write hook');
+  if (args.requireGates || args.requireWriteHook) {
+    let writeRequest = null;
+    if (args.requireWriteHook) {
+      writeRequest = validateHardWriteRequest({
+        root: args.root,
+        host: args.requireWriteHook,
+        tools: [args.requireWriteHook],
+        force: true,
+      });
+      if (!writeRequest.ok) {
+        const payload = {
+          ok: false,
+          error: 'unsupported-enforcement-profile',
+          message: writeRequest.error,
+        };
+        if (args.json) console.log(JSON.stringify(payload, null, 2));
+        else console.error(writeRequest.error);
+        process.exitCode = 2;
+        return;
+      }
+    }
+
+    const missing = args.requireGates ? missingGates(args.root) : [];
+    if (
+      writeRequest?.host &&
+      !detectWritePathCapabilities(args.root, writeRequest.host).capabilities['hard-write']
+    ) {
+      missing.push(`${writeRequest.host} hard-write hook`);
     }
     if (missing.length > 0) {
       const payload = {
         ok: false,
         error: 'missing-gates',
         missing,
+        ...(writeRequest?.host ? { writeHost: writeRequest.host } : {}),
       };
       if (args.json) {
         console.log(JSON.stringify(payload, null, 2));
@@ -994,7 +1026,12 @@ async function main() {
         for (const relativePath of missing) {
           console.error(`  - ${relativePath}`);
         }
-        console.error(`\nRun \`${arkCommand(args.root, 'ark', 'init')}\` (or \`ark-check --install-agent-gates\`) to configure enforcement.`);
+        const installArgs = writeRequest?.host
+          ? `--install-agent-gates --tools ${writeRequest.host} --require-write-hook ${writeRequest.host}`
+          : '--install-agent-gates';
+        console.error(
+          `\nRun \`${arkCommand(args.root, 'ark', 'init')}\` (or \`${arkCommand(args.root, 'ark-check', installArgs)}\`) to configure enforcement.`
+        );
       }
       process.exitCode = 1;
       return;
@@ -1004,7 +1041,18 @@ async function main() {
     // When --require-gates is the only intent (no config/architecture run needed),
     // callers still get a clear signal from the exit code and the human-mode line.
     if (!args.json) {
-      console.log('Ark gates present: ' + REQUIRED_GATE_FILES.join(', '));
+      if (args.requireGates) {
+        const compactHost = compactRouterHost(args.root);
+        console.log(
+          'Ark gates present (merge profile): ' +
+            (compactHost
+              ? `AGENTS.md, compact host registration (${compactHost})`
+              : REQUIRED_GATE_FILES.join(', '))
+        );
+      }
+      if (writeRequest?.host) {
+        console.log(`Ark hard-write hook present for ${writeRequest.host}.`);
+      }
     }
   }
 
@@ -1277,10 +1325,28 @@ async function main() {
         }
       }
     }
+
+    // Best-effort: open the report in the default browser. If it opens, fine;
+    // if not (headless, no GUI, spawn error), do nothing — never fail the check.
+    // Skipped in CI / Vitest / ARK_NO_OPEN_REPORT; --open / --no-open override.
+    if (
+      shouldOpenHtmlReport({
+        force: Boolean(args.openReport),
+        noOpen: Boolean(args.noOpenReport) || Boolean(args.json),
+      })
+    ) {
+      openHtmlInBrowser(reportPath);
+    }
   }
 
   if (args.json) {
+    const adapterResult = createAdapterResult({
+      valid: ok,
+      violations: activeViolations.map(enrichViolationWithFixClass),
+      warnings,
+    });
     console.log(JSON.stringify({
+      ...adapterResult,
       ok,
       violations: activeViolations.map(enrichViolationWithFixClass),
       suppressedViolations: suppressed.length,
@@ -1385,10 +1451,19 @@ async function main() {
       const parts = [];
       if (codexHomeGap.missing > 0) parts.push(`${codexHomeGap.missing} missing`);
       if (codexHomeGap.stale > 0) parts.push(`${codexHomeGap.stale} outdated`);
+      // Advisory always; when session host is known and not Codex, say so so
+      // /ark-upgrade does not chase home prompts as Incomplete.
+      const activeHost = detectActiveAgentHost();
+      const deferredNote =
+        activeHost != null && activeHost !== 'codex'
+          ? ' Deferred unless you use Codex — not a blocker for Grok/Claude/Cursor. '
+          : ' ';
       console.log(
         color.dim(
-          `/ark-* skills in ${codexPromptsDir()} are behind this Ark (${parts.join(', ')}). ` +
-            `Codex loads them from there, not the repo. Refresh: ${arkCommand(root, 'ark-check', '--install-agent-gates --skills-only --codex-home --force')}`
+          `/ark-* skills in ${codexPromptsDir()} are behind this Ark (${parts.join(', ')}).` +
+            deferredNote +
+            `Codex loads them from $CODEX_HOME/prompts, not the repo. ` +
+            `When using Codex: ${arkCommand(root, 'ark-check', '--install-agent-gates --skills-only --codex-home --force')}`
         )
       );
     }
@@ -1430,9 +1505,13 @@ async function runWatchMode(args) {
     const target = path.join(args.root, entry);
     if (!fs.existsSync(target)) continue;
     try {
-      fs.watch(target, { recursive: true }, rerun);
+      const watcher = fs.watch(target, { recursive: true }, rerun);
+      watcher.on('error', () => {
+        watcher.close();
+        watchByPolling(target, rerun);
+      });
     } catch {
-      fs.watch(target, rerun);
+      watchByPolling(target, rerun);
     }
   }
 
@@ -1440,7 +1519,45 @@ async function runWatchMode(args) {
   await new Promise(() => {});
 }
 
+function watchByPolling(target, onChange) {
+  let previous = watchFingerprint(target);
+  setInterval(() => {
+    const current = watchFingerprint(target);
+    if (current === previous) return;
+    previous = current;
+    onChange();
+  }, 250);
+}
+
+function watchFingerprint(target) {
+  const pending = [target];
+  const entries = [];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    let stat;
+    try {
+      stat = fs.statSync(current);
+    } catch {
+      continue;
+    }
+    entries.push(`${current}:${stat.mtimeMs}:${stat.size}`);
+    if (!stat.isDirectory()) continue;
+    try {
+      for (const name of fs.readdirSync(current)) pending.push(path.join(current, name));
+    } catch {
+      // A concurrent delete is represented by the next fingerprint.
+    }
+  }
+  return entries.sort().join('|');
+}
+
 main().catch((error) => {
-  console.error(error instanceof Error ? error.message : String(error));
+  console.error(
+    process.env.ARK_DEBUG_STACK === '1' && error instanceof Error
+      ? error.stack
+      : error instanceof Error
+        ? error.message
+        : String(error)
+  );
   process.exitCode = 2;
 });

package/bin/ark-mcp.mjs

@@ -58,6 +58,8 @@ import {
 import { createImportTargetResolver } from './lib/import-resolve.mjs';
 import { validateWithAutoPatch, resolveImportFileAbs } from './lib/auto-patch.mjs';
 import { composePrepareWrite } from './lib/prepare-write.mjs';
+import { loadArkConfigContract } from './lib/config-contract.mjs';
+import { ARK_ANALYSIS_RESULT_SCHEMA, createAdapterResult } from './lib/adapter-contract.mjs';
 
 const arkCheckBin = fileURLToPath(new URL('./ark-check.mjs', import.meta.url));
 
@@ -120,6 +122,11 @@ function readJson(file, { required } = {}) {
   }
 }
 
+function readArkConfig(file, { required } = {}) {
+  const raw = readJson(file, { required });
+  return raw === undefined ? undefined : loadArkConfigContract(raw, file).config;
+}
+
 function resolveInRoot(root, maybePath) {
   if (!maybePath) return undefined;
   return path.isAbsolute(maybePath) ? maybePath : path.join(root, maybePath);
@@ -173,6 +180,8 @@ function normalizeHookPayload(payload) {
     Edit: 'Edit',
     search_replace: 'Edit',
     MultiEdit: 'MultiEdit',
+    ApplyPatch: 'ApplyPatch',
+    apply_patch: 'ApplyPatch',
   };
   const toolName = nameMap[rawName] ?? rawName;
   const filePath =
@@ -187,6 +196,70 @@ function normalizeHookPayload(payload) {
   };
 }
 
+function applyCodexUpdatePatch(current, lines) {
+  let source = current.split('\n');
+  let cursor = 0;
+  const hunks = [];
+  let hunk = [];
+  for (const line of lines) {
+    if (line.startsWith('@@')) {
+      if (hunk.length > 0) hunks.push(hunk);
+      hunk = [];
+    } else if (/^[ +\-]/.test(line)) {
+      hunk.push(line);
+    }
+  }
+  if (hunk.length > 0) hunks.push(hunk);
+  for (const entries of hunks) {
+    const oldLines = entries.filter((line) => !line.startsWith('+')).map((line) => line.slice(1));
+    const newLines = entries.filter((line) => !line.startsWith('-')).map((line) => line.slice(1));
+    let found = -1;
+    for (let at = cursor; at <= source.length - oldLines.length; at += 1) {
+      if (oldLines.every((line, index) => source[at + index] === line)) {
+        found = at;
+        break;
+      }
+    }
+    if (found < 0) return null;
+    source.splice(found, oldLines.length, ...newLines);
+    cursor = found + newLines.length;
+  }
+  return source.join('\n');
+}
+
+function codexPatchWrites(patch, root) {
+  if (typeof patch !== 'string' || !patch.includes('*** Begin Patch')) return [];
+  const lines = patch.split('\n');
+  const writes = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const match = lines[index].match(/^\*\*\* (Add|Update|Delete) File: (.+)$/);
+    if (!match) continue;
+    const [, action, relativePath] = match;
+    const body = [];
+    for (index += 1; index < lines.length && !lines[index].startsWith('*** '); index += 1) {
+      body.push(lines[index]);
+    }
+    index -= 1;
+    if (action === 'Delete') continue;
+    const filePath = path.resolve(root, relativePath);
+    let content;
+    if (action === 'Add') {
+      content = body.filter((line) => line.startsWith('+')).map((line) => line.slice(1)).join('\n');
+      if (body.some((line) => line.startsWith('+'))) content += '\n';
+    } else {
+      let current;
+      try {
+        current = fs.readFileSync(filePath, 'utf8');
+      } catch {
+        continue;
+      }
+      content = applyCodexUpdatePatch(current, body);
+    }
+    if (typeof content === 'string') writes.push({ filePath, content });
+  }
+  return writes;
+}
+
 /**
  * Compute the file content a Write/Edit/MultiEdit is about to produce. Edits are applied
  * to the CURRENT on-disk file so the gate judges the real post-edit state, not the edit
@@ -231,7 +304,27 @@ function runHook(gate, config, args, ts) {
     return;
   }
 
+  runHookPayload(payload, gate, config, args, ts);
+}
+
+function runHookPayload(payload, gate, config, args, ts) {
   const { toolName, toolInput, grokStyle } = normalizeHookPayload(payload);
+  if (toolName === 'ApplyPatch') {
+    const patch = toolInput.patch ?? toolInput.input ?? toolInput.content;
+    for (const write of codexPatchWrites(patch, args.root)) {
+      runHookPayload(
+        {
+          tool_name: 'Write',
+          tool_input: { file_path: write.filePath, content: write.content },
+        },
+        gate,
+        config,
+        args,
+        ts
+      );
+    }
+    return;
+  }
   const filePath = toolInput.file_path;
   if (!['Write', 'Edit', 'MultiEdit'].includes(toolName)) return;
   if (typeof filePath !== 'string' || !SOURCE_FILE.test(filePath) || filePath.endsWith('.d.ts')) {
@@ -292,6 +385,11 @@ function runHook(gate, config, args, ts) {
     return false;
   });
   if (newViolations.length === 0) return;
+  const normalizedRel = rel.split(path.sep).join('/');
+  const adapterResult = createAdapterResult({
+    valid: false,
+    violations: newViolations.map((violation) => ({ ...violation, file: normalizedRel })),
+  });
 
   const lines = newViolations.map(
     (violation) =>
@@ -333,9 +431,10 @@ function runHook(gate, config, args, ts) {
   if (repair) {
     // Structured envelope for any host that can re-inject. Never writes the file.
     const repairPayload = {
+      ...adapterResult,
       mode: 'repair',
       decision: 'deny',
-      filePath: rel.split(path.sep).join('/'),
+      filePath: normalizedRel,
       ...(layer ? { layer } : {}),
       ...(autoPatch
         ? {
@@ -361,6 +460,7 @@ function runHook(gate, config, args, ts) {
       JSON.stringify({
         decision: 'deny',
         reason: message,
+        analysis: adapterResult,
         ...(repair && autoPatch ? { autoPatch } : {}),
         ...(repair ? { repair: true } : {}),
       }) + '\n'
@@ -460,11 +560,11 @@ async function main() {
   const ts = await loadOptionalTypeScript();
 
   const config =
-    (configPath ? readJson(configPath, { required: args.configExplicit }) : undefined) ?? {
-      include: ['src'],
-      layers: [],
-      rules: [],
-    };
+    (configPath ? readArkConfig(configPath, { required: args.configExplicit }) : undefined) ??
+    loadArkConfigContract(
+      { include: ['src'], layers: [], rules: DEFAULT_RULES },
+      configPath ?? 'ark.config.json'
+    ).config;
   if (!config.layers || config.layers.length === 0) {
     process.stderr.write(
       '[ark-mcp] warning: no layers configured — file→layer inference from config patterns ' +
@@ -610,6 +710,7 @@ async function main() {
         },
         required: ['source'],
       },
+      outputSchema: ARK_ANALYSIS_RESULT_SCHEMA,
     },
     {
       name: 'ark_check',
@@ -632,6 +733,7 @@ async function main() {
           },
         },
       },
+      outputSchema: ARK_ANALYSIS_RESULT_SCHEMA,
     },
     {
       name: 'ark_coverage',
@@ -820,12 +922,17 @@ async function main() {
       validate: validateOnce,
       resolveTargetAbs: resolveImportFileAbs,
     });
+    const adapterResult = createAdapterResult({
+      valid: result.valid,
+      violations: result.violations,
+    });
     return {
       content: [
         {
           type: 'text',
           text: JSON.stringify(
             {
+              ...adapterResult,
               valid: result.valid,
               violations: result.violations,
               ...(result.autoPatch ? { autoPatch: result.autoPatch } : {}),
@@ -836,6 +943,7 @@ async function main() {
           ),
         },
       ],
+      structuredContent: adapterResult,
       isError: !result.valid,
     };
   }
@@ -862,6 +970,11 @@ async function main() {
     }
     return {
       content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+      structuredContent: {
+        schemaVersion: data.schemaVersion,
+        valid: data.valid,
+        diagnostics: data.diagnostics,
+      },
       isError: data.ok === false,
     };
   }