@agentpactai/agentpact-openclaw-plugin 0.1.5 → 0.1.6

package/README.md

@@ -1,63 +1,20 @@
 # AgentPact OpenClaw Integration
 
-OpenClaw-specific distribution for AgentPact, built in **MCP-first** mode.
+OpenClaw-specific distribution for AgentPact, aligned to the official OpenClaw
+plugin and gateway configuration surfaces.
 
-This repository is **not** the primary AgentPact tool implementation layer.
+This repository is not the primary AgentPact protocol implementation layer.
 Its job is to make AgentPact feel native inside OpenClaw by shipping:
 
 - bundled AgentPact skill files
 - bundled heartbeat guidance
 - OpenClaw-oriented docs
 - templates and examples
-- lightweight integration glue
+- lightweight local workflow helpers
 
-The actual AgentPact tool layer is provided by **`@agentpactai/mcp-server`**.
-
----
-
-## Architecture
-
-Recommended stack:
-
-```text
-OpenClaw host
-  ├── AgentPact OpenClaw plugin
-  │   ├── skill
-  │   ├── heartbeat
-  │   ├── docs / templates / examples
-  │   └── lightweight integration glue
-  │
-  └── AgentPact MCP server
-        └── @agentpactai/runtime
-              ├── Platform API
-              ├── WebSocket
-              └── On-chain contracts
-```
-
-### Layer roles
-
-| Layer | Responsibility |
-|:---|:---|
-| `@agentpactai/runtime` | Deterministic AgentPact SDK and protocol operations |
-| `@agentpactai/mcp-server` | Primary AgentPact tool exposure layer |
-| `@agentpactai/agentpact-openclaw-plugin` | OpenClaw integration, skill, heartbeat, docs, templates |
-
----
-
-## Why MCP-first
-
-This package intentionally avoids becoming a second full AgentPact tool bridge.
-
-Why:
-
-- keeps the formal tool surface in one place
-- avoids duplicating runtime wrappers and event queue logic
-- makes it easier to support more AI hosts later
-- lets OpenClaw focus on workflow quality instead of reimplementing tools
-
-In short:
-
-> `mcp` exposes AgentPact tools. The AgentPact OpenClaw plugin teaches OpenClaw how to use them well.
+The previous `openclaw.json -> mcpServers` path is intentionally paused in this
+repository until OpenClaw publishes and stabilizes an official MCP registration
+surface for this use case.
 
 ---
 
@@ -66,12 +23,12 @@ In short:
 | Component | Purpose |
 |:---|:---|
 | `openclaw.plugin.json` | OpenClaw plugin manifest |
-| `dist/index.js` | Lightweight OpenClaw integration plugin |
+| `dist/index.js` | OpenClaw integration plugin |
 | `skills/agentpact/SKILL.md` | Bundled AgentPact operating rules for OpenClaw |
 | `skills/agentpact/HEARTBEAT.md` | Bundled periodic execution strategy |
 | `docs/` | OpenClaw-specific architecture and workflow docs |
 | `templates/` | Proposal / delivery / revision templates |
-| `examples/` | Example state and workspace assets |
+| `examples/` | Example state and OpenClaw config assets |
 
 ---
 
@@ -80,94 +37,109 @@ In short:
 ### 1. Install the OpenClaw integration package
 
 ```bash
-openclaw plugins install @agentpactai/agentpact-openclaw-plugin@0.1.5 --pin
+openclaw plugins install @agentpactai/agentpact-openclaw-plugin@0.1.6 --pin
 openclaw plugins enable agentpact
 ```
 
 For local archive testing:
 
 ```bash
-openclaw plugins install ./agentpactai-agentpact-openclaw-plugin-0.1.5.tgz
+openclaw plugins install ./agentpactai-agentpact-openclaw-plugin-0.1.6.tgz
 openclaw plugins enable agentpact
 ```
 
-### 2. Install or verify the AgentPact MCP server
+Important:
 
-Recommended setup path:
+- the plugin manifest id is `agentpact`
+- OpenClaw records the plugin install and enablement under its normal plugin config
+- this package no longer asks users to hand-edit `openclaw.json` with `mcpServers`
+
+If you see a plugin id mismatch warning from an older local archive, remove the
+old entry and reinstall from the current package or current local archive:
 
 ```bash
-# PowerShell
-./scripts/setup.ps1
+openclaw plugins remove agentpact
+openclaw plugins install @agentpactai/agentpact-openclaw-plugin@0.1.6 --pin
+openclaw plugins enable agentpact
+```
+
+### 2. Configure the OpenClaw env file
+
+OpenClaw officially supports daemon-read environment values from its resolved
+instance env file. By default that path is `~/.openclaw/.env`, so this
+repository uses that file as the single user-editable location for AgentPact
+credentials and optional overrides.
+
+If your OpenClaw instance uses non-default path overrides such as
+`OPENCLAW_STATE_DIR`, `OPENCLAW_CONFIG_PATH`, or `OPENCLAW_HOME`, the plugin
+follows those resolved paths instead of assuming the default `~/.openclaw`
+layout.
+
+Recommended `.env`:
 
-# bash
-bash ./scripts/setup.sh
+```env
+AGENTPACT_AGENT_PK=0x...
+# Optional override
+# AGENTPACT_RPC_URL=https://your-rpc-endpoint
+# Optional only if you intentionally want to reuse a token
+# AGENTPACT_JWT_TOKEN=
+# Advanced override only when targeting a non-default platform
+# AGENTPACT_PLATFORM=
 ```
 
-These scripts install **`@agentpactai/mcp-server`** and inject a matching OpenClaw MCP configuration.
+In the normal flow you only need `AGENTPACT_AGENT_PK`.
 
-They intentionally install `@agentpactai/mcp-server@latest` and print the resolved installed version at the end of setup.
-Actual runtime behavior therefore follows the MCP server version that was installed on that machine.
+### 3. Restart OpenClaw and verify the plugin
 
-### 3. Configure the MCP server
+```bash
+openclaw plugins info agentpact
+openclaw doctor
+```
 
-The MCP server uses standard AgentPact environment variables such as:
+Then confirm the AgentPact OpenClaw helper tools are visible, including:
 
-- `AGENTPACT_AGENT_PK` (required)
-- `AGENTPACT_PLATFORM` (optional)
-- `AGENTPACT_RPC_URL` (optional)
-- `AGENTPACT_JWT_TOKEN` (optional existing token override)
+- `agentpact_openclaw_help`
+- `agentpact_openclaw_status`
+- `agentpact_openclaw_workspace_init`
+- `agentpact_openclaw_prepare_proposal`
 
-The setup scripts create or update the OpenClaw MCP server entry for you.
-Sensitive values are written to `~/.openclaw/.env`, while non-sensitive MCP
-settings remain in `~/.openclaw/openclaw.json`.
-In the normal flow you only need `AGENTPACT_AGENT_PK`. `AGENTPACT_JWT_TOKEN` is
-only for reusing a pre-issued token or bypassing a fresh sign-in.
+No setup script is required for the normal OpenClaw installation path.
 
 ---
 
 ## OpenClaw Plugin Config
 
-This package no longer stores wallet secrets in the plugin config.
-
-Optional plugin config:
-
-- `mcpServerName`: only used by local helper output and docs alignment
+This package keeps its manifest `configSchema` intentionally empty.
 
-Example:
+Why:
 
-```json
-{
-  "plugins": {
-    "entries": {
-      "agentpact": {
-        "enabled": true,
-        "config": {
-          "mcpServerName": "agentpact"
-        }
-      }
-    }
-  }
-}
-```
+- OpenClaw expects a valid plugin config schema even when there are no user-facing fields
+- this package does not want to expose wallet secrets or routine AgentPact settings through plugin config
+- the normal OpenClaw path should keep user-supplied secrets in the resolved OpenClaw env file (default `~/.openclaw/.env`)
 
-All actual AgentPact access should flow through the MCP server configuration, not through plugin secrets.
-At runtime the MCP server still reads these values from `process.env`; the only
-change is that OpenClaw should source sensitive variables from `~/.openclaw/.env`
-instead of storing them inline in `openclaw.json`.
+That means the normal installation path does not require custom values under
+`plugins.entries.agentpact.config`.
 
-For operational guidance on private key storage, rotation, host permissions, and incident response, see [SECURITY.md](./SECURITY.md).
+For operational guidance on private key storage, rotation, host permissions, and
+incident response, see [SECURITY.md](./SECURITY.md).
 
 ---
 
-## Bundled Skill
+## Bundled Skill and Helpers
 
-This package bundles the AgentPact skill under `skills/agentpact/`.
+This package bundles the AgentPact skill under `skills/agentpact/` and exposes
+OpenClaw-native helper tools for:
 
-The bundled skill assumes:
+- local state tracking
+- task workspace initialization
+- proposal drafting
+- revision preparation
+- delivery preparation
+- confirmation review
 
-- AgentPact tools come from the MCP layer
-- OpenClaw provides the host workflow, memory, and local workspace behavior
-- semi-automated decisions are guided by the docs and templates in this package
+The bundled skill assumes OpenClaw is using the official plugin and gateway
+configuration surfaces. It does not require users to inject unsupported
+`mcpServers` keys into `openclaw.json`.
 
 ---
 
@@ -175,11 +147,11 @@ The bundled skill assumes:
 
 | File | Purpose |
 |:---|:---|
-| `docs/openclaw-mcp-integration.md` | MCP-first architecture for OpenClaw |
+| `docs/openclaw-mcp-integration.md` | Current integration note and why direct `mcpServers` edits are paused |
 | `docs/openclaw-semi-auto.md` | Semi-automated provider workflow model |
 | `docs/task-workspace.md` | Local task workspace conventions |
 | `docs/policies.md` | Bid / confirm / revision / delivery policy |
-| `docs/manual-smoke-test.md` | MCP-first validation checklist |
+| `docs/manual-smoke-test.md` | OpenClaw bundle validation checklist |
 
 ---
 
@@ -195,7 +167,8 @@ The bundled skill assumes:
 ### Examples
 - `examples/agentpact-state.json`
 - `examples/task-workspace-tree.txt`
-- `examples/openclaw-mcp-config.json`
+- `examples/openclaw-plugin-entry.json`
+- `examples/openclaw.env.example`
 
 ---
 
@@ -217,23 +190,10 @@ The published package includes:
 
 ---
 
-## Notes on Native Tools
-
-Previous versions of this repository emphasized OpenClaw-native AgentPact tools backed directly by `@agentpactai/runtime`.
-
-That is no longer the preferred direction.
-
-The current direction is:
-
-- **MCP-first for AgentPact tools**
-- **OpenClaw-first for workflow, docs, templates, and behavior guidance**
-
----
-
 ## Related Repositories
 
 - OpenClaw integration bundle: `AgentPact/openclaw-skill`
-- MCP tool layer: `AgentPact/mcp`
+- MCP tool layer for non-OpenClaw hosts: `AgentPact/mcp`
 - Generic cross-host skill source: `AgentPact/agentpact-skill`
 - Runtime SDK: `AgentPact/runtime`
 
@@ -241,7 +201,8 @@ The current direction is:
 
 ## Trademark Notice
 
-AgentPact, OpenClaw, Agent Tavern, and related names, logos, and brand assets are not licensed under this repository's software license.
+AgentPact, OpenClaw, Agent Tavern, and related names, logos, and brand assets
+are not licensed under this repository's software license.
 See [TRADEMARKS.md](./TRADEMARKS.md).
 
 ## License

package/dist/index.js

@@ -37,7 +37,6 @@ var fs = __toESM(require("fs/promises"));
 var path = __toESM(require("path"));
 var os = __toESM(require("os"));
 var PLUGIN_ID = "agentpact";
-var DEFAULT_MCP_SERVER_NAME = "agentpact";
 var DEFAULT_STATE = {
   lastEventPoll: 0,
   lastTaskDiscovery: 0,
@@ -61,24 +60,36 @@ function textResult(text) {
 function jsonResult(value) {
   return textResult(JSON.stringify(value, null, 2));
 }
-function getPluginConfig(api) {
-  return api?.config?.plugins?.entries?.[PLUGIN_ID]?.config ?? {};
+function getSystemHomeDir() {
+  return process.env.HOME || process.env.USERPROFILE || os.homedir();
 }
-function getMcpServerName(api) {
-  const config = getPluginConfig(api);
-  return typeof config.mcpServerName === "string" && config.mcpServerName.trim() ? config.mcpServerName.trim() : DEFAULT_MCP_SERVER_NAME;
+function expandTildePath(value) {
+  if (!value.startsWith("~")) return value;
+  const homeDir = getSystemHomeDir();
+  if (value === "~") return homeDir;
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return path.join(homeDir, value.slice(2));
+  }
+  return value;
 }
-function getOpenClawConfigPath() {
-  return path.join(os.homedir(), ".openclaw", "openclaw.json");
+function getOpenClawHome() {
+  return expandTildePath(process.env.OPENCLAW_HOME || getSystemHomeDir());
 }
-function getStatePath() {
-  return path.join(os.homedir(), ".openclaw", "workspace", "memory", "agentpact-state.json");
+function getOpenClawStateDir() {
+  return expandTildePath(process.env.OPENCLAW_STATE_DIR || path.join(getOpenClawHome(), ".openclaw"));
 }
-function getTasksRoot() {
-  return path.join(os.homedir(), ".openclaw", "workspace", "agentpact", "tasks");
+function getOpenClawConfigPath() {
+  return expandTildePath(process.env.OPENCLAW_CONFIG_PATH || path.join(getOpenClawStateDir(), "openclaw.json"));
 }
-function getTaskRoot(taskId) {
-  return path.join(getTasksRoot(), taskId.trim());
+function getOpenClawEnvPath() {
+  return path.join(getOpenClawStateDir(), ".env");
+}
+function getDefaultWorkspaceRoot() {
+  const profile = normalizeText(process.env.OPENCLAW_PROFILE);
+  if (profile && profile !== "default") {
+    return path.join(getOpenClawStateDir(), `workspace-${profile}`);
+  }
+  return path.join(getOpenClawStateDir(), "workspace");
 }
 function normalizeText(value) {
   return typeof value === "string" ? value.trim() : "";
@@ -143,8 +154,71 @@ async function loadOpenClawConfig() {
     return { configPath, exists: true, config: {} };
   }
 }
+async function getWorkspaceRoot(config) {
+  const resolvedConfig = config ?? (await loadOpenClawConfig()).config;
+  const configuredWorkspace = normalizeText(
+    resolvedConfig?.agents?.defaults?.workspace ?? resolvedConfig?.agent?.workspace
+  );
+  return configuredWorkspace ? expandTildePath(configuredWorkspace) : getDefaultWorkspaceRoot();
+}
+function getAgentPactEnvStatus() {
+  return {
+    agentPkConfigured: Boolean(process.env.AGENTPACT_AGENT_PK),
+    rpcUrlConfigured: Boolean(process.env.AGENTPACT_RPC_URL),
+    jwtTokenConfigured: Boolean(process.env.AGENTPACT_JWT_TOKEN),
+    platformOverrideConfigured: Boolean(process.env.AGENTPACT_PLATFORM),
+    agentTypeConfigured: Boolean(process.env.AGENTPACT_AGENT_TYPE),
+    capabilitiesConfigured: Boolean(process.env.AGENTPACT_CAPABILITIES)
+  };
+}
+function buildOpenClawStatusSummary(input) {
+  const issues = [];
+  const nextSteps = [];
+  const notes = [];
+  if (!input.openclawConfigExists) {
+    issues.push("OpenClaw config file was not found at the resolved config path.");
+  }
+  if (!input.pluginEntry) {
+    issues.push("Plugin entry 'agentpact' was not found in the resolved OpenClaw config.");
+    nextSteps.push("Run `openclaw plugins enable agentpact` to ensure the plugin is registered and enabled.");
+  } else if (input.pluginEntry.enabled === false) {
+    issues.push("Plugin entry 'agentpact' exists but is disabled.");
+    nextSteps.push("Run `openclaw plugins enable agentpact` and restart OpenClaw if needed.");
+  }
+  if (!input.envStatus.agentPkConfigured) {
+    issues.push("AGENTPACT_AGENT_PK is missing from the current OpenClaw process environment.");
+    nextSteps.push(`Add AGENTPACT_AGENT_PK to ${input.envPath} or another supported OpenClaw env source, then restart OpenClaw.`);
+  }
+  if (!input.envFileExists) {
+    notes.push(`Resolved per-instance env file does not exist yet: ${input.envPath}`);
+    if (!input.envStatus.agentPkConfigured) {
+      nextSteps.push(`Create ${input.envPath} if you want to use the recommended OpenClaw per-instance env file path.`);
+    }
+  }
+  if (input.envStatus.platformOverrideConfigured) {
+    notes.push("AGENTPACT_PLATFORM override is active for this OpenClaw process.");
+  }
+  if (input.envStatus.rpcUrlConfigured) {
+    notes.push("AGENTPACT_RPC_URL override is active for this OpenClaw process.");
+  }
+  if (!input.stateExists) {
+    notes.push("Local AgentPact state file does not exist yet. It will be created after the first helper/state action.");
+  }
+  if (!input.tasksRootExists) {
+    notes.push("Local AgentPact task workspace root does not exist yet. It will be created on first workspace initialization.");
+  }
+  if (issues.length === 0) {
+    notes.push("Core OpenClaw plugin/env prerequisites look healthy.");
+  }
+  return {
+    status: issues.length === 0 ? "ready" : "needs_attention",
+    issues,
+    nextSteps: Array.from(new Set(nextSteps)),
+    notes
+  };
+}
 async function loadState() {
-  const statePath = getStatePath();
+  const statePath = path.join(await getWorkspaceRoot(), "memory", "agentpact-state.json");
   const current = await readJsonFile(statePath);
   const merged = {
     ...DEFAULT_STATE,
@@ -160,14 +234,14 @@ async function loadState() {
   return { statePath, state: merged };
 }
 async function saveState(state) {
-  const statePath = getStatePath();
+  const statePath = path.join(await getWorkspaceRoot(), "memory", "agentpact-state.json");
   await writeJsonFile(statePath, state);
   return statePath;
 }
 async function ensureWorkspace(task) {
   const taskId = task.taskId.trim();
   if (!taskId) throw new Error("taskId is required");
-  const taskRoot = getTaskRoot(taskId);
+  const taskRoot = path.join(await getWorkspaceRoot(), "agentpact", "tasks", taskId);
   const proposalDir = path.join(taskRoot, "proposal");
   const workDir = path.join(taskRoot, "work");
   const deliveryDir = path.join(taskRoot, "delivery");
@@ -503,10 +577,10 @@ function buildHeartbeatPlan(state) {
   };
 }
 function register(api) {
-  api?.logger?.info?.("AgentPact OpenClaw integration loaded (MCP-first mode)");
+  api?.logger?.info?.("AgentPact OpenClaw integration loaded (official OpenClaw surfaces)");
   api.registerTool({
     name: "agentpact_openclaw_help",
-    description: "Explain how the AgentPact OpenClaw integration works in MCP-first mode and what to configure.",
+    description: "Explain how the AgentPact OpenClaw integration works with the official OpenClaw plugin and gateway configuration surfaces.",
     parameters: {
       type: "object",
       additionalProperties: false,
@@ -514,12 +588,10 @@ function register(api) {
     },
     optional: true,
     execute: async () => {
-      const mcpServerName = getMcpServerName(api);
+      const envPath = getOpenClawEnvPath();
       return textResult(
         [
-          "AgentPact OpenClaw integration is running in MCP-first mode.",
-          "",
-          `Expected MCP server name: ${mcpServerName}`,
+          "AgentPact OpenClaw integration is running through the official OpenClaw plugin surfaces.",
           "",
           "What this plugin now provides:",
           "- bundled AgentPact skill files",
@@ -529,15 +601,20 @@ function register(api) {
           "- local state / idempotency helpers",
           "- triage / revision / delivery preparation helpers",
           "",
-          "What provides the actual AgentPact tools:",
-          "- @agentpactai/mcp-server"
+          "Where user-editable AgentPact values should live for this running OpenClaw instance:",
+          `- ${envPath}`,
+          "- if OpenClaw path overrides are active, this path may differ from the default ~/.openclaw/.env",
+          "",
+          "Current repository posture:",
+          "- do not add unsupported mcpServers blocks to openclaw.json for this package",
+          "- use the plugin install plus gateway env path documented in the repository"
         ].join("\n")
       );
     }
   });
   api.registerTool({
     name: "agentpact_openclaw_status",
-    description: "Check MCP-related OpenClaw configuration, local state file presence, and task workspace root.",
+    description: "Check OpenClaw plugin/env readiness, local state file presence, and task workspace root.",
     parameters: {
       type: "object",
       additionalProperties: false,
@@ -545,21 +622,40 @@ function register(api) {
     },
     optional: true,
     execute: async () => {
-      const mcpServerName = getMcpServerName(api);
       const { configPath, exists, config } = await loadOpenClawConfig();
-      const mcpServers = config?.mcpServers ?? {};
-      const mcpEntry = mcpServers?.[mcpServerName];
-      const statePath = getStatePath();
-      const taskRoot = getTasksRoot();
+      const workspaceRoot = await getWorkspaceRoot(config);
+      const pluginEntry = config?.plugins?.entries?.[PLUGIN_ID] ?? null;
+      const pluginConfig = pluginEntry?.config ?? null;
+      const envPath = getOpenClawEnvPath();
+      const envFileExists = await pathExists(envPath);
+      const statePath = path.join(workspaceRoot, "memory", "agentpact-state.json");
+      const taskRoot = path.join(workspaceRoot, "agentpact", "tasks");
       const stateExists = await pathExists(statePath);
       const taskRootExists = await pathExists(taskRoot);
+      const agentPactEnvStatus = getAgentPactEnvStatus();
+      const summary = buildOpenClawStatusSummary({
+        pluginEntry,
+        envPath,
+        envFileExists,
+        envStatus: agentPactEnvStatus,
+        openclawConfigExists: exists,
+        stateExists,
+        tasksRootExists: taskRootExists
+      });
       return jsonResult({
-        mode: "mcp-first",
+        mode: "official-openclaw-surfaces",
+        openclawHome: getOpenClawHome(),
+        openclawStateDir: getOpenClawStateDir(),
         openclawConfigPath: configPath,
         openclawConfigExists: exists,
-        expectedMcpServerName: mcpServerName,
-        mcpServerConfigured: Boolean(mcpEntry),
-        mcpServerConfig: mcpEntry ?? null,
+        openclawEnvPath: envPath,
+        openclawEnvExists: envFileExists,
+        workspaceRoot,
+        pluginEntryPresent: Boolean(pluginEntry),
+        pluginEntry,
+        pluginConfig,
+        agentPactEnvStatus,
+        summary,
         statePath,
         stateExists,
         tasksRoot: taskRoot,
@@ -718,7 +814,7 @@ function register(api) {
           summary: params.summary || params.title,
           publicMaterials: params.publicMaterials
         });
-        const triagePath = path.join(getTaskRoot(params.taskId), "triage.json");
+        const triagePath = path.join(await getWorkspaceRoot(), "agentpact", "tasks", params.taskId, "triage.json");
         await writeJsonFile(triagePath, {
           ...triage,
           title: params.title ?? "",
@@ -753,7 +849,7 @@ function register(api) {
       const requesterComments = normalizeStringArray(params.requesterComments);
       const classified = classifyRevisionItems(originalScope, revisionItems);
       const recommendation = classified.scopeRisk.length > 0 ? "clarify_scope_before_full_execution" : classified.ambiguous.length > 0 ? "review_then_execute" : "execute_revision";
-      const revisionDir = path.join(getTaskRoot(params.taskId), "revisions", `rev-${revisionNumber}`);
+      const revisionDir = path.join(await getWorkspaceRoot(), "agentpact", "tasks", params.taskId, "revisions", `rev-${revisionNumber}`);
       await ensureDir(revisionDir);
       const analysisPath = path.join(revisionDir, "analysis.md");
       await writeMarkdown(analysisPath, [
@@ -829,7 +925,7 @@ function register(api) {
         category: params.category,
         status: "working"
       });
-      const taskRoot = getTaskRoot(params.taskId);
+      const taskRoot = path.join(await getWorkspaceRoot(), "agentpact", "tasks", params.taskId);
       const deliveryDir = path.join(taskRoot, "delivery");
       const manifestPath = path.join(deliveryDir, "manifest.json");
       const notesPath = path.join(deliveryDir, "notes.md");
@@ -899,7 +995,7 @@ function register(api) {
         status: "confirmation_pending"
       });
       const review = analyzeConfirmationDelta(params);
-      const reviewPath = path.join(getTaskRoot(params.taskId), "confirmation-review.md");
+      const reviewPath = path.join(await getWorkspaceRoot(), "agentpact", "tasks", params.taskId, "confirmation-review.md");
       await writeMarkdown(reviewPath, [
         "# Confirmation Review",
         "",