@entrorove/skill 0.1.1

package/AGREEMENT.md

@@ -0,0 +1,51 @@
+# Entrorove 使用、隐私与广告信息协议
+
+版本：2026-09-29
+
+本协议是首次使用 Entrorove 技能时的合并告知与使用条款。只有用户明确选择“同意”后，技能请求才会发送。IDE 的“完全访问”权限只是本地权限，不代表同意本协议。
+
+## 1. 技能与权限
+
+- Entrorove 会按用户与 IDE 明确提供的任务、上下文和权限辅助分析、修改代码及运行检查。
+- 高权限操作可能修改或删除文件、运行命令或调用外部服务。用户应检查范围、保留备份，并对有重大后果的操作单独确认。
+- 本协议不扩大 IDE 已授予的权限，也不替代具体高风险操作所需的单独确认。
+
+## 2. 隐私与数据
+
+- 安装包不会因安装本身自动扫描或上传项目文件。只有在发起技能调用时，才会向 Entrorove API 发送 IDE 明确组装的请求负载。
+- 账号服务会处理登录邮箱、密钥哈希与前缀、加密保存的完整密钥、会话与安全记录、调用时间/数量，以及用户自愿提交的留言。已登录用户可再次复制自己的完整密钥。
+- 当前实现不将项目源文件或技能任务负载写入业务数据库，不使用个人信息决定广告展示，不出售个人信息。
+- 本地同意回执仅保存协议版本、同意结果和时间，不包含邮箱、项目内容或密钥。
+
+## 3. 消息与广告
+
+- 在长时间任务的“请勿关闭”提示下，服务可按后台配置追加一条带 HTTPS 链接的消息。
+- 商业内容以后台配置的分类标签显示为 `【分类】`，不伪装成执行结果、系统警告或独立推荐。
+- 推广仅在配置的有效期内按权重随机展示；多条推广的权重共同决定展示概率及选择频率。选择不使用用户画像、项目内容或个人信息。
+- 广告链接指向第三方时，第三方的内容、隐私与条款由其自行负责。
+
+## 4. 风险与责任限制
+
+- 技能按现状提供，不保证所有结果均正确、完整、不中断或适合特定目的。用户应在合并、发布或用于生产前审查修改并运行适当检查。
+- 在适用法律允许的最大范围内，Entrorove 不承担因使用或无法使用技能导致的间接、附带、特殊或后果性损失。
+- 上述限制不排除法律不允许排除的责任，也不限制欺诈、故意不当行为或适用法律规定的强制性消费者权利。
+
+## 5. 同意、拒绝与更新
+
+- 选择“同意”表示已阅读并接受本版本协议；选择“不同意”时，技能请求不会发送。
+- 重要条款或数据实践变更时将更新协议版本并重新请求明确确认。
+- 不同国家和地区的强制性法律可能授予额外权利；本协议不会覆盖这些权利。正式发布前应由合格法律顾问按实际经营地、用户地区和数据流程复核。
+
+---
+
+# Entrorove Terms, Privacy and Advertising Notice
+
+Version: 2026-09-29
+
+This combined notice applies on first use. A skill request is sent only after an explicit **Accept** choice. Granting an IDE “full access” permission does not accept this agreement.
+
+- **Use and access.** Entrorove acts only on tasks, context and permissions supplied by the user and IDE. Elevated permissions may permit file changes, command execution and external calls. Review scope, keep backups and separately confirm consequential actions.
+- **Data.** Installation alone does not scan or upload project files. The account service processes login email, key hashes and prefixes, an encrypted copy of the full key that a signed-in user can copy again, sessions and security records, invocation time/count, and messages submitted voluntarily. Skill request payloads are received for execution; the current implementation does not store project source files or task payloads in its business database. It does not sell personal information or use personal information to select ads.
+- **Advertising.** A configured message may appear beneath a long-running-task notice. Commercial content carries its configured category label as `【Category】`, includes an HTTPS link, and is selected by the weights of eligible messages without profiling or targeting. Third-party links are governed by their operators.
+- **Risk.** The skill is provided as available without a guarantee that every result is correct, complete, uninterrupted or fit for a particular purpose. Review and test changes before production use. To the maximum extent permitted by applicable law, Entrorove excludes indirect, incidental, special and consequential losses. Nothing excludes non-waivable liability, fraud, wilful misconduct or mandatory consumer rights.
+- **Choice.** Declining prevents the skill request from being sent. Material changes require a new explicit acceptance. Mandatory local laws may provide additional rights. Qualified counsel should review this notice before production release for the actual operating and user jurisdictions.

package/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: entrorove
+description: An engineering skill that understands a task, chooses a fitting workflow, keeps progress traceable, and verifies the result.
+---
+
+# entrorove · 熵巡
+
+Version: 0.1.1.
+
+Read the user's goal and repository instructions first. Preserve the original task through planning, execution and verification. Use the workflow only where it helps; a small, low-risk edit can proceed directly. Never claim a reported step is a verified result.
+
+Install or update the managed copy with `npx @entrorove/skill install`. The installer removes only pristine duplicate entrorove installations and preserves unmanaged files.
+
+Register or sign in by email at https://entrorove.com. Enter the account key with `npx @entrorove/skill configure` and `{"token":"..."}` on standard input. Never place it in arguments, URLs, project files or logs. Entrorove accounts and keys are independent of other services.
+
+On first use, the CLI returns a Confirm Protocol-compatible agreement interaction. Render it with the IDE's native confirmation UI, or show its `chatFallback` text when no adapter exists. The user must explicitly accept with `npx @entrorove/skill agreement` and JSON `{"version":"2026-09-29","answer":"accept"}` on standard input before retrying the skill request. A full-access IDE permission never counts as agreement acceptance. The combined terms, privacy and advertising notice is installed as `AGREEMENT.md`.
+
+## Work with a task
+
+Send JSON on standard input to `npx @entrorove/skill invoke`. Start with `operation: "start"` and an `input.task` containing the goal, work type, risk, difficulty and observed scope facts. Work types are `implementation`, `documentation`, `calculation`, `merge`, `review` and `decision`. Assess facts from the real task and repository; do not invent certainty. Entrorove chooses the workflow. A small task may return `decision: "direct"`, meaning the IDE should do the work without another service call.
+
+```json
+{"operation":"start","input":{"task":{"goal":"Update the checkout flow and verify it","workType":"implementation","risk":"medium","difficulty":"medium","crossModule":true,"parallel":false,"unclear":false,"architectureContract":false}}}
+```
+
+For a returned `flowId`, continue with `{"operation":"continue","input":{"flowId":"<returned ID>","operation":"<next operation>","payload":{}}}`. Fill `payload` with the next operation's required input. Keep the same task and evidence in the IDE. For later work, `input.task.phase` may be `plan`, `coordinate`, `architecture`, `verify`, `merge` or `decision`; it remains the same skill entry point. Never treat an unknown request outcome as permission to retry a paid or mutating action; query the original request ID when the workflow supports it.
+
+For a decision, include `input.task.interaction` with `type` (`confirm`, `choice`, `multi` or `input`), a `question`, `options` (two or more with unique `id` and `label`, or an empty array for input), and a `callback` containing its `operation` and `payload`. Medium- and high-risk decisions also need a `riskDescription`. The decision waits for an explicit answer; it never chooses a default on timeout.
+
+The live API and install package must be deployed and published before this command works outside the local checkout.
+
+When the user gives an actual evaluation after using the skill, offer to publish that feedback. Only after they explicitly agree to public display, send their own words, IDE name and 1–5 rating as JSON on standard input to `npx @entrorove/skill review` with `publicConsent: true`. Never invent, rewrite or infer a review from task completion. The website reads accepted reviews directly from Entrorove's independent database.

package/cli.mjs

@@ -0,0 +1,490 @@
+#!/usr/bin/env node
+import { createHash, randomUUID } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const packageDir = path.dirname(fileURLToPath(import.meta.url));
+const apiUrl = 'https://entrorove.com/api/skill/invoke';
+const reviewUrl = 'https://entrorove.com/api/ide-reviews';
+const markerName = '.entrorove-managed.json';
+const installFiles = ['SKILL.md', 'AGREEMENT.md', 'manifest.json'];
+const markerSchema = 'entrorove.managed-install/1.0';
+const credentialSchema = 'entrorove.credential/1.0';
+const agreementSchema = 'entrorove.agreement-acceptance/1.0';
+const invocationTimeoutMs = 135_000;
+const installLockWaitMs = 10_000;
+const installLockStaleMs = 120_000;
+export const agreementVersion = '2026-09-29';
+
+function sha256(content) {
+  return createHash('sha256').update(content).digest('hex');
+}
+
+async function readJson(file) {
+  const value = JSON.parse(await fs.readFile(file, 'utf8'));
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`Invalid JSON object: ${file}`);
+  }
+  return value;
+}
+
+async function sourceBundle() {
+  const manifest = await readJson(path.join(packageDir, 'manifest.json'));
+  const packageMetadata = await readJson(path.join(packageDir, 'package.json'));
+  if (manifest.schemaVersion !== 'entrorove.skill-manifest/1.0'
+    || manifest.name !== 'entrorove'
+    || manifest.endpoint !== 'https://entrorove.com'
+    || manifest.requestSchemaVersion !== 'entrorove.skill.request/1.0'
+    || !/^\d+\.\d+\.\d+$/.test(manifest.version)
+    || packageMetadata.name !== '@entrorove/skill'
+    || packageMetadata.version !== manifest.version) {
+    throw new Error('Invalid entrorove package manifest');
+  }
+  const content = new Map();
+  for (const name of installFiles) {
+    content.set(name, await fs.readFile(path.join(packageDir, name)));
+  }
+  if (!content.get('SKILL.md').toString('utf8').includes(`Version: ${manifest.version}.`)) {
+    throw new Error('Entrorove skill instructions have a mismatched version');
+  }
+  const hashes = Object.fromEntries(installFiles.map((name) => [name, sha256(content.get(name))]));
+  return { manifest, content, hashes };
+}
+
+function globalInstallPath(home = os.homedir()) {
+  return path.join(home, '.codex', 'skills', 'entrorove');
+}
+
+function credentialPath(home = os.homedir()) {
+  if (process.platform === 'win32') {
+    const appData = process.env.LOCALAPPDATA;
+    if (!appData || !path.isAbsolute(appData)) throw new Error('LOCALAPPDATA is required');
+    return path.join(appData, 'Entrorove', 'credential.json');
+  }
+  if (process.platform === 'darwin') {
+    return path.join(home, 'Library', 'Application Support', 'Entrorove', 'credential.json');
+  }
+  return path.join(home, '.local', 'share', 'entrorove', 'credential.json');
+}
+
+function agreementPath(home = os.homedir()) {
+  return path.join(path.dirname(credentialPath(home)), 'agreement.json');
+}
+
+export function agreementInteraction() {
+  return {
+    schemaVersion: 'confirm.interaction/1.0',
+    requestId: `entrorove-agreement-${agreementVersion}`,
+    type: 'confirm',
+    question: `首次使用前，请阅读 Entrorove 使用、隐私与广告信息协议（${agreementVersion}）。是否同意？`,
+    options: [
+      { id: 'accept', label: '同意', hint: '记录本地回执并允许后续技能调用' },
+      { id: 'decline', label: '不同意', hint: '不发送技能请求' },
+    ],
+    default: null,
+    timeout: null,
+    timeoutAction: 'wait',
+    risk: 'high',
+    riskDescription: '这是使用条款、隐私告知、广告告知与责任限制的明确确认。',
+    rememberable: false,
+    memoryKey: '',
+    callback: { operation: 'agreement', payload: { version: agreementVersion } },
+  };
+}
+
+function agreementRequired(home) {
+  const agreement = path.join(globalInstallPath(home), 'AGREEMENT.md');
+  return {
+    ok: false,
+    error: 'agreement-required',
+    agreementVersion,
+    agreement,
+    interaction: agreementInteraction(),
+    chatFallback: [
+      `Entrorove 首次使用确认（${agreementVersion}）`,
+      `请先阅读：${agreement}`,
+      '1. accept — 同意并继续',
+      '2. decline — 不同意，不发送请求',
+      '完全访问权限不代表协议同意。',
+    ].join('\n'),
+  };
+}
+
+async function statOrNull(file) {
+  try {
+    return await fs.lstat(file);
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+async function managedState(directory) {
+  const directoryStat = await statOrNull(directory);
+  if (!directoryStat) return null;
+  if (!directoryStat.isDirectory() || directoryStat.isSymbolicLink()) return false;
+  const entries = await fs.readdir(directory);
+  if (!entries.includes(markerName)) return false;
+  const markerStat = await fs.lstat(path.join(directory, markerName));
+  if (!markerStat.isFile() || markerStat.isSymbolicLink()) return false;
+  let marker;
+  try {
+    marker = await readJson(path.join(directory, markerName));
+  } catch {
+    return false;
+  }
+  const markerFiles = marker.files && typeof marker.files === 'object' && !Array.isArray(marker.files)
+    ? Object.keys(marker.files) : [];
+  if (marker.schemaVersion !== markerSchema || marker.name !== 'entrorove'
+    || typeof marker.version !== 'string' || !/^\d+\.\d+\.\d+$/.test(marker.version)
+    || !markerFiles.includes('SKILL.md') || !markerFiles.includes('manifest.json')
+    || markerFiles.some((name) => !installFiles.includes(name))
+    || entries.slice().sort().join(',') !== [...markerFiles, markerName].sort().join(',')) {
+    return false;
+  }
+  for (const name of markerFiles) {
+    const file = path.join(directory, name);
+    const fileStat = await fs.lstat(file);
+    if (!fileStat.isFile() || fileStat.isSymbolicLink()) return false;
+    if (!/^[a-f0-9]{64}$/.test(marker.files[name])) return false;
+    if (sha256(await fs.readFile(file)) !== marker.files[name]) return false;
+  }
+  return marker;
+}
+
+async function writeStagedInstall(directory, bundle) {
+  await fs.mkdir(directory, { mode: 0o700 });
+  for (const name of installFiles) {
+    await fs.writeFile(path.join(directory, name), bundle.content.get(name), { flag: 'wx', mode: 0o600 });
+  }
+  const marker = { schemaVersion: markerSchema, name: 'entrorove', version: bundle.manifest.version, files: bundle.hashes };
+  await fs.writeFile(path.join(directory, markerName), JSON.stringify(marker) + '\n', { flag: 'wx', mode: 0o600 });
+}
+
+async function removeStaleInstallLock(lock) {
+  const state = await statOrNull(lock);
+  if (!state) return true;
+  if (!state.isDirectory() || state.isSymbolicLink()) {
+    throw new Error('Entrorove install lock is not a directory');
+  }
+  if (Date.now() - state.mtimeMs < installLockStaleMs) return false;
+  let owner;
+  try {
+    owner = await readJson(path.join(lock, 'owner.json'));
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+  if (Number.isSafeInteger(owner?.pid) && owner.pid > 0) {
+    try {
+      process.kill(owner.pid, 0);
+      return false;
+    } catch (error) {
+      if (error.code !== 'ESRCH') return false;
+    }
+  }
+  const quarantine = `${lock}.stale-${randomUUID()}`;
+  try {
+    await fs.rename(lock, quarantine);
+  } catch (error) {
+    if (error.code === 'ENOENT') return true;
+    throw error;
+  }
+  const moved = await fs.lstat(quarantine);
+  if (moved.ino !== state.ino || moved.dev !== state.dev) {
+    await fs.rename(quarantine, lock);
+    throw new Error('Entrorove install lock changed during stale recovery');
+  }
+  await fs.rm(quarantine, { recursive: true });
+  return true;
+}
+
+async function withInstallLock(parent, action) {
+  const lock = path.join(parent, '.entrorove-install.lock');
+  const deadline = Date.now() + installLockWaitMs;
+  while (true) {
+    try {
+      await fs.mkdir(lock, { mode: 0o700 });
+      break;
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+      if (await removeStaleInstallLock(lock)) continue;
+      if (Date.now() >= deadline) throw new Error('Entrorove install is busy');
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+  }
+  try {
+    await fs.writeFile(path.join(lock, 'owner.json'), JSON.stringify({ pid: process.pid }),
+      { flag: 'wx', mode: 0o600 });
+    return await action();
+  } finally {
+    await fs.rm(lock, { recursive: true });
+  }
+}
+
+async function updateGlobalInstall(target, bundle) {
+  const parent = path.dirname(target);
+  await fs.mkdir(parent, { recursive: true, mode: 0o700 });
+  const previous = await managedState(target);
+  if (previous === false) throw new Error('Global entrorove skill is not pristine and managed; refusing overwrite');
+  if (previous?.version === bundle.manifest.version
+    && installFiles.every((name) => previous.files[name] === bundle.hashes[name])) return false;
+  const stage = path.join(parent, `.entrorove-stage-${randomUUID()}`);
+  const backup = path.join(parent, `.entrorove-backup-${randomUUID()}`);
+  await writeStagedInstall(stage, bundle);
+  let moved = false;
+  try {
+    if (previous) {
+      await fs.rename(target, backup);
+      moved = true;
+    }
+    await fs.rename(stage, target);
+  } catch (error) {
+    if (moved) await fs.rename(backup, target);
+    throw error;
+  } finally {
+    if (await statOrNull(stage)) await fs.rm(stage, { recursive: true });
+  }
+  if (moved) await fs.rm(backup, { recursive: true });
+  return true;
+}
+
+function projectRoot(cwd) {
+  try {
+    return execFileSync('git', ['-C', cwd, 'rev-parse', '--show-toplevel'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function gitTracked(root, relativePath) {
+  const files = execFileSync('git', ['-C', root, 'ls-files', '--cached', '--', relativePath], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+  return files.trim().length > 0;
+}
+
+async function removeManagedDuplicate(directory, root) {
+  if (gitTracked(root, path.relative(root, directory))) return false;
+  if (!await managedState(directory)) return false;
+  const quarantine = `${directory}.entrorove-cleanup-${randomUUID()}`;
+  await fs.rename(directory, quarantine);
+  try {
+    if (!await managedState(quarantine)) throw new Error('Managed duplicate changed during cleanup');
+    await fs.rm(quarantine, { recursive: true });
+  } catch (error) {
+    await fs.rename(quarantine, directory);
+    throw error;
+  }
+  return true;
+}
+
+async function cleanProjectDuplicates(target, cwd) {
+  const root = projectRoot(cwd);
+  if (!root) return [];
+  const removed = [];
+  for (const relative of ['.codex/skills/entrorove', '.agents/skills/entrorove', '.claude/skills/entrorove']) {
+    const directory = path.join(root, relative);
+    if (directory === target) continue;
+    if (await removeManagedDuplicate(directory, root)) removed.push(relative);
+  }
+  return removed;
+}
+
+export async function install({ home = os.homedir(), cwd = process.cwd() } = {}) {
+  const bundle = await sourceBundle();
+  const target = globalInstallPath(home);
+  const parent = path.dirname(target);
+  await fs.mkdir(parent, { recursive: true, mode: 0o700 });
+  return withInstallLock(parent, async () => {
+    const updated = await updateGlobalInstall(target, bundle);
+    const removed = await cleanProjectDuplicates(target, cwd);
+    return { version: bundle.manifest.version, updated, removed };
+  });
+}
+
+async function stdinJson() {
+  let raw = '';
+  for await (const chunk of process.stdin) {
+    raw += chunk;
+    if (raw.length > 1_000_000) throw new Error('Input is too large');
+  }
+  const value = JSON.parse(raw);
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('Input must be a JSON object');
+  return value;
+}
+
+async function writeCredential(token, home) {
+  if (typeof token !== 'string' || !/^ent_[A-Za-z0-9_-]{16,256}$/.test(token)) {
+    throw new Error('Invalid entrorove key');
+  }
+  const file = credentialPath(home);
+  const parent = path.dirname(file);
+  await fs.mkdir(parent, { recursive: true, mode: 0o700 });
+  if (process.platform !== 'win32') await fs.chmod(parent, 0o700);
+  const existing = await statOrNull(file);
+  if (existing && (!existing.isFile() || existing.isSymbolicLink())) throw new Error('Credential path is not a regular file');
+  const stage = path.join(parent, `.credential-${randomUUID()}.tmp`);
+  const handle = await fs.open(stage, 'wx', 0o600);
+  try {
+    await handle.writeFile(JSON.stringify({ schemaVersion: credentialSchema, token }) + '\n');
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  await fs.rename(stage, file);
+  if (process.platform !== 'win32') await fs.chmod(file, 0o600);
+}
+
+async function readCredential(home) {
+  const file = credentialPath(home);
+  const stat = await fs.lstat(file);
+  if (!stat.isFile() || stat.isSymbolicLink()) throw new Error('Credential path is not a regular file');
+  if (process.platform !== 'win32' && (stat.mode & 0o077) !== 0) throw new Error('Credential permissions must be 0600');
+  const data = await readJson(file);
+  if (data.schemaVersion !== credentialSchema || typeof data.token !== 'string'
+    || !/^ent_[A-Za-z0-9_-]{16,256}$/.test(data.token)) throw new Error('Invalid credential file');
+  return data.token;
+}
+
+async function agreementAccepted(home) {
+  const file = agreementPath(home);
+  const stat = await statOrNull(file);
+  if (!stat) return false;
+  if (!stat.isFile() || stat.isSymbolicLink()) throw new Error('Agreement path is not a regular file');
+  if (process.platform !== 'win32' && (stat.mode & 0o077) !== 0) {
+    throw new Error('Agreement acceptance permissions must be 0600');
+  }
+  const data = await readJson(file);
+  return data.schemaVersion === agreementSchema && data.version === agreementVersion
+    && data.answer === 'accept' && typeof data.acceptedAt === 'string'
+    && Number.isFinite(Date.parse(data.acceptedAt));
+}
+
+async function writeAgreementAcceptance(data, home) {
+  if (Object.keys(data).sort().join(',') !== 'answer,version'
+    || data.version !== agreementVersion || !['accept', 'decline'].includes(data.answer)) {
+    throw new Error(`Expected {"version":"${agreementVersion}","answer":"accept|decline"} on stdin`);
+  }
+  if (data.answer === 'decline') return false;
+  const file = agreementPath(home);
+  const parent = path.dirname(file);
+  await fs.mkdir(parent, { recursive: true, mode: 0o700 });
+  if (process.platform !== 'win32') await fs.chmod(parent, 0o700);
+  const existing = await statOrNull(file);
+  if (existing && (!existing.isFile() || existing.isSymbolicLink())) {
+    throw new Error('Agreement path is not a regular file');
+  }
+  const stage = path.join(parent, `.agreement-${randomUUID()}.tmp`);
+  await fs.writeFile(stage, JSON.stringify({
+    schemaVersion: agreementSchema,
+    version: agreementVersion,
+    answer: 'accept',
+    acceptedAt: new Date().toISOString(),
+  }) + '\n', { flag: 'wx', mode: 0o600 });
+  await fs.rename(stage, file);
+  if (process.platform !== 'win32') await fs.chmod(file, 0o600);
+  return true;
+}
+
+export function buildInvocation(operation, input) {
+  if (operation !== 'start' && operation !== 'continue') throw new Error('Invalid entrorove operation');
+  if (!input || typeof input !== 'object' || Array.isArray(input)) throw new Error('Input must be a JSON object');
+  const requestId = randomUUID();
+  return { url: apiUrl, requestId, body: { schemaVersion: 'entrorove.skill.request/1.0', requestId, operation, input } };
+}
+
+async function invoke(data) {
+  await install();
+  if (!await agreementAccepted(os.homedir())) {
+    process.stdout.write(JSON.stringify(agreementRequired(os.homedir())) + '\n');
+    process.exitCode = 2;
+    return;
+  }
+  const call = buildInvocation(data.operation, data.input);
+  const token = await readCredential(os.homedir());
+  let response;
+  try {
+    response = await fetch(call.url, {
+      method: 'POST', redirect: 'error', signal: AbortSignal.timeout(invocationTimeoutMs),
+      headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` },
+      body: JSON.stringify(call.body),
+    });
+  } catch {
+    throw new Error(`Invocation outcome is unknown; requestId=${call.requestId}. Do not automatically resend this request.`);
+  }
+  if (!response.ok) throw new Error(`entrorove invocation failed: HTTP ${response.status}; requestId=${call.requestId}`);
+  let result;
+  try {
+    result = await response.json();
+  } catch {
+    throw new Error(`Invocation outcome is unknown; requestId=${call.requestId}. Do not automatically resend this request.`);
+  }
+  if (result?.ok !== true || result.output?.requestId !== call.requestId) {
+    throw new Error(`Invalid entrorove response; requestId=${call.requestId}`);
+  }
+  process.stdout.write(JSON.stringify(result) + '\n');
+}
+
+export function buildReview(data) {
+  if (!data || typeof data !== 'object' || Array.isArray(data)
+    || Object.keys(data).sort().join(',') !== 'comment,ide,publicConsent,rating'
+    || typeof data.ide !== 'string' || !/^[\p{L}\p{N} .+_-]{2,48}$/u.test(data.ide.trim())
+    || !Number.isInteger(data.rating) || data.rating < 1 || data.rating > 5
+    || typeof data.comment !== 'string' || data.comment.trim().length < 4
+    || data.comment.trim().length > 280 || data.publicConsent !== true) {
+    throw new Error('Expected user-authored review with ide, rating 1-5, comment, and publicConsent:true');
+  }
+  return {
+    url: reviewUrl,
+    body: {
+      ide: data.ide.trim(), rating: data.rating,
+      comment: data.comment.trim(), publicConsent: true,
+    },
+  };
+}
+
+async function submitReview(data) {
+  const review = buildReview(data);
+  const token = await readCredential(os.homedir());
+  const response = await fetch(review.url, {
+    method: 'POST', redirect: 'error', signal: AbortSignal.timeout(15_000),
+    headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` },
+    body: JSON.stringify(review.body),
+  });
+  if (!response.ok) throw new Error(`entrorove review failed: HTTP ${response.status}`);
+  const result = await response.json();
+  if (result?.published !== true || typeof result.id !== 'string') {
+    throw new Error('Invalid entrorove review response');
+  }
+  process.stdout.write(JSON.stringify(result) + '\n');
+}
+
+async function main() {
+  const [command, ...args] = process.argv.slice(2);
+  if (command === 'install' && args.length === 0) {
+    process.stdout.write(JSON.stringify(await install()) + '\n');
+  } else if (command === 'configure' && args.length === 0) {
+    const data = await stdinJson();
+    if (Object.keys(data).length !== 1 || typeof data.token !== 'string') throw new Error('Expected {"token":"..."} on stdin');
+    await writeCredential(data.token, os.homedir());
+    process.stdout.write('{"configured":true}\n');
+  } else if (command === 'agreement' && args.length === 0) {
+    await install();
+    const accepted = await writeAgreementAcceptance(await stdinJson(), os.homedir());
+    process.stdout.write(JSON.stringify({ accepted, version: agreementVersion }) + '\n');
+  } else if (command === 'invoke' && args.length === 0) {
+    await invoke(await stdinJson());
+  } else if (command === 'review' && args.length === 0) {
+    await submitReview(await stdinJson());
+  } else {
+    throw new Error('Usage: entrorove install | configure | agreement | invoke | review (JSON on stdin)');
+  }
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main().catch((error) => {
+    process.stderr.write(`${error.message}\n`);
+    process.exitCode = 1;
+  });
+}

package/manifest.json

@@ -0,0 +1,7 @@
+{
+  "schemaVersion": "entrorove.skill-manifest/1.0",
+  "name": "entrorove",
+  "version": "0.1.1",
+  "endpoint": "https://entrorove.com",
+  "requestSchemaVersion": "entrorove.skill.request/1.0"
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@entrorove/skill",
+  "version": "0.1.1",
+  "type": "module",
+  "bin": {
+    "entrorove": "cli.mjs"
+  },
+  "files": [
+    "cli.mjs",
+    "SKILL.md",
+    "AGREEMENT.md",
+    "manifest.json"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}