@xmemo/skill 1.1.25

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Yonro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,34 @@
+# @xmemo/skill
+
+Standalone installer and distribution package for the official [XMemo](https://xmemo.dev) agent skill.
+
+## Quick Start
+
+Install the skill into your local project or agent environment (zero network, offline):
+
+```bash
+npx @xmemo/skill install
+```
+
+### Installation Options
+
+- `--target <dir>`: Specify destination directory (default: `xmemo-skill`, or `$XMEMO_SKILL_DIR`)
+- `--dry-run`: Preview installation actions without writing files
+- `--force`: Overwrite destination directory if it already exists
+- `--json`: Output machine-readable JSON report
+
+## Commands
+
+- `xmemo-skill install`: Install the bundled skill files
+- `xmemo-skill version`: Print the skill version (`1.1.25`)
+- `xmemo-skill help`: Display command usage and options
+
+## Package Integrity
+
+- **Zero dependencies**: Uses Node.js standard library only (`fs`, `path`, `crypto`, `url`, `process`).
+- **Offline only**: The installer performs zero network requests and transmits no credentials.
+- **Byte-identical**: The staged skill payload matches the verified GitHub Release archive.
+
+## License
+
+MIT

package/bin/install.mjs

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import { realpathSync } from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import process from 'node:process';
+
+const PACKAGE_NAME = '@xmemo/skill';
+const DEFAULT_INSTALL_DIR = 'xmemo-skill';
+
+export async function locateSkillSource(metaUrl = import.meta.url) {
+  const currentDir = path.dirname(fileURLToPath(metaUrl));
+  const candidateStaged = path.resolve(currentDir, '..', 'skill');
+
+  const stagedStat = await fs.stat(candidateStaged).catch(() => null);
+  if (stagedStat?.isDirectory()) return candidateStaged;
+
+  throw new Error(`Could not locate bundled skill directory: ${candidateStaged}`);
+}
+
+export async function readSkillVersion(source) {
+  for (const required of ['SKILL.md', path.join('scripts', 'xmemo-skill.mjs')]) {
+    const stat = await fs.stat(path.join(source, required)).catch(() => null);
+    if (!stat?.isFile()) throw new Error(`Missing required Skill file: ${required}`);
+  }
+  const runtime = await fs.readFile(path.join(source, 'scripts', 'xmemo-skill.mjs'), 'utf8');
+  const match = runtime.match(/const SKILL_VERSION = '([^']+)';/);
+  if (!match?.[1]) throw new Error('The XMemo Skill version could not be determined from scripts/xmemo-skill.mjs.');
+  return match[1];
+}
+
+function resolveRealPath(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    const parent = path.dirname(p);
+    try {
+      return path.join(realpathSync(parent), path.basename(p));
+    } catch {
+      return path.resolve(p);
+    }
+  }
+}
+
+export function assertSafeTarget(packageRoot, source, target) {
+  if (target === path.parse(target).root) {
+    throw new Error('Refusing to install a Skill into a filesystem root.');
+  }
+  const realPkg = resolveRealPath(packageRoot);
+  const realSource = resolveRealPath(source);
+  const realTarget = resolveRealPath(target);
+
+  const relPkg = path.relative(realPkg, realTarget);
+  if (!relPkg || (!relPkg.startsWith('..') && !path.isAbsolute(relPkg))) {
+    throw new Error('Skill destination cannot be the package root or a directory inside it.');
+  }
+  const relSource = path.relative(realSource, realTarget);
+  if (!relSource || (!relSource.startsWith('..') && !path.isAbsolute(relSource))) {
+    throw new Error('Skill destination cannot be the skill source or a directory inside it.');
+  }
+}
+
+export async function pathExists(target) {
+  try {
+    await fs.access(target);
+    return true;
+  } catch (error) {
+    if (error?.code === 'ENOENT') return false;
+    throw error;
+  }
+}
+
+export async function atomicInstall(source, target, replace, { rename = fs.rename } = {}) {
+  const parent = path.dirname(target);
+  const base = path.basename(target);
+  const nonce = `${process.pid}-${randomUUID()}`;
+  const staging = path.join(parent, `.${base}.xmemo-staging-${nonce}`);
+  const backup = path.join(parent, `.${base}.xmemo-backup-${nonce}`);
+  let movedExisting = false;
+
+  await fs.mkdir(parent, { recursive: true });
+  try {
+    await fs.cp(source, staging, { recursive: true, errorOnExist: true, force: false });
+    if (replace) {
+      await rename(target, backup);
+      movedExisting = true;
+    }
+    await rename(staging, target);
+    if (movedExisting) {
+      await fs.rm(backup, { recursive: true, force: true });
+      movedExisting = false;
+    }
+  } catch (error) {
+    if (movedExisting && !(await pathExists(target))) {
+      await rename(backup, target).catch(() => {});
+    }
+    throw error;
+  } finally {
+    await fs.rm(staging, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+export function parseInstallOptions(args) {
+  const flags = new Set(['--dry-run', '--force', '--json']);
+  const seen = new Set();
+  let target = undefined;
+  let dryRun = false;
+  let force = false;
+  let json = false;
+
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+    if (token === '--help' || token === '-h') {
+      return { help: true };
+    }
+    if (token === '--target') {
+      if (seen.has(token)) throw new Error('Duplicate option: --target.');
+      const val = args[i + 1];
+      if (!val || val.startsWith('-')) throw new Error('Option --target requires a value.');
+      target = val;
+      seen.add(token);
+      i += 1;
+      continue;
+    }
+    if (!flags.has(token)) {
+      throw new Error(`Unknown skill install option: ${token}`);
+    }
+    if (seen.has(token)) {
+      throw new Error(`Duplicate option: ${token}.`);
+    }
+    seen.add(token);
+    if (token === '--dry-run') dryRun = true;
+    if (token === '--force') force = true;
+    if (token === '--json') json = true;
+  }
+
+  return { help: false, target, dryRun, force, json };
+}
+
+export function printHelp(stdout = console.log) {
+  stdout('XMemo Skill installer (@xmemo/skill)');
+  stdout('');
+  stdout('Usage:');
+  stdout('  xmemo-skill install [--target <dir>] [--dry-run] [--force] [--json]');
+  stdout('  xmemo-skill version [--json]');
+  stdout('  xmemo-skill help');
+  stdout('');
+  stdout('Commands:');
+  stdout('  install   Install the XMemo Skill locally (offline, zero-network)');
+  stdout('  version   Print the skill version');
+  stdout('  help      Print this help message');
+  stdout('');
+  stdout('Options:');
+  stdout('  --target <dir>   Installation directory (default: xmemo-skill, or $XMEMO_SKILL_DIR)');
+  stdout('  --dry-run        Simulate installation without writing files');
+  stdout('  --force          Overwrite destination directory if it already exists');
+  stdout('  --json           Output results as JSON');
+}
+
+export async function runCli(argv = process.argv.slice(2), { cwd = process.cwd(), env = process.env, metaUrl = import.meta.url } = {}) {
+  const subcommand = argv[0] ?? 'help';
+
+  if (subcommand === 'help' || subcommand === '--help' || subcommand === '-h') {
+    printHelp();
+    return 0;
+  }
+
+  const source = await locateSkillSource(metaUrl);
+  const packageRoot = path.resolve(path.dirname(fileURLToPath(metaUrl)), '..');
+  const skillVersion = await readSkillVersion(source);
+
+  if (subcommand === 'version' || subcommand === '--version' || subcommand === '-v') {
+    const isJson = argv.includes('--json');
+    if (isJson) {
+      console.log(JSON.stringify({ package: PACKAGE_NAME, version: skillVersion, skillVersion }, null, 2));
+    } else {
+      console.log(skillVersion);
+    }
+    return 0;
+  }
+
+  if (subcommand !== 'install') {
+    throw new Error(`Unknown command: ${subcommand}. Run "xmemo-skill help" for usage.`);
+  }
+
+  const optionArgs = argv.slice(1);
+  const options = parseInstallOptions(optionArgs);
+  if (options.help) {
+    printHelp();
+    return 0;
+  }
+
+  const targetDir = options.target ?? env.XMEMO_SKILL_DIR ?? DEFAULT_INSTALL_DIR;
+  const target = path.resolve(cwd, targetDir);
+
+  assertSafeTarget(packageRoot, source, target);
+
+  const exists = await pathExists(target);
+  if (exists && !options.force) {
+    throw new Error(`Skill destination already exists: ${target}. Use --force to replace it.`);
+  }
+
+  const report = {
+    package: PACKAGE_NAME,
+    skillVersion,
+    source,
+    target,
+    dryRun: options.dryRun,
+    force: options.force,
+    replaced: exists && !options.dryRun,
+    installed: false,
+    networkUsed: false,
+    tokenSent: false,
+  };
+
+  if (!options.dryRun) {
+    await atomicInstall(source, target, exists);
+    report.installed = true;
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log(`${options.dryRun ? 'Would install' : 'Installed'} XMemo Skill ${skillVersion} to ${target}`);
+    console.log(`Source: ${PACKAGE_NAME} ${skillVersion} (offline; no credential used)`);
+  }
+
+  return 0;
+}
+
+function isDirectExecution() {
+  if (!process.argv[1]) return false;
+  const currentPath = fileURLToPath(import.meta.url);
+  if (process.argv[1] === currentPath || path.resolve(process.argv[1]) === currentPath) {
+    return true;
+  }
+  try {
+    return realpathSync(process.argv[1]) === realpathSync(currentPath);
+  } catch {
+    return false;
+  }
+}
+
+if (isDirectExecution()) {
+  runCli().catch((err) => {
+    console.error(err.message || String(err));
+    process.exit(1);
+  });
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@xmemo/skill",
+  "version": "1.1.25",
+  "description": "Standalone installer and distribution package for the XMemo agent skill.",
+  "type": "module",
+  "bin": {
+    "xmemo-skill": "bin/install.mjs"
+  },
+  "files": [
+    "bin",
+    "skill",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yonro/memory-os-cli.git",
+    "directory": "skills/xmemo"
+  },
+  "license": "MIT"
+}

package/skill/CHANGELOG.md

@@ -0,0 +1,279 @@
+# XMemo Skill Change Log
+
+## [Unreleased]
+
+## 1.1.25
+
+### Added
+
+- Support Meta Muse Secure Vault credentials (credential resolution order: `XMEMO_KEY` → `muse-vault` surrogate token via local socket → user credential file; surrogate tokens are restricted strictly to `https://xmemo.dev` and are never stored to disk or printed).
+- Support OpenClaw secret egress proxying: `XMEMO_KEY` holding an OpenClaw sentinel token is reported as `openclaw-secret`; outbound requests fail closed unless the egress proxy environment (`HTTPS_PROXY` or `https_proxy`, and truthy `NODE_USE_ENV_PROXY`) is active, and sentinels are only sent to `https://xmemo.dev`.
+
+## 1.1.24
+
+### Changed
+
+- Enforce a 512 KiB input size limit on `remember` via stdin and `--file` (matching the server single-item limit), using bounded reads that reject non-regular files and prevent unbounded buffering.
+- Standardize `restart-snapshot` and `restart-restore` failure output under `--json` mode into the unified `{ok: false, error: {code, message, request_id}}` envelope, preserving HTTP exit code mapping.
+- Split monolithic operations reference into scoped `memory-operations.md`, `ledger-operations.md`, and `runtime-operations.md` guides (each under 12 KB), updating cross-document links and security documentation phrasing.
+
+## 1.1.23
+
+### Changed
+
+- Split the runtime into a small entrypoint plus `scripts/lib/` and `scripts/commands/` modules (12 files, each under 12 KB). Commands, options, terminal and `--json` output, exit codes, and installation are unchanged.
+
+## 1.1.22
+
+### Changed
+
+- Lean skill package: removed maintainer smoke test script (`smoke-test.mjs`) and release workflow documentation, keeping only consumer skill assets; maintainer workflows migrated to repository-level `scripts/` and `docs/`.
+
+## 1.1.21
+
+### Fixed
+
+- Wrap `restart-snapshot` and `restart-restore` successful `--json` output in standard `{"ok": true}` envelope matching other skill commands.
+
+## 1.1.20
+
+### Added
+
+- Add pre-release smoke-test script (`scripts/smoke-test.mjs`) to validate exit codes, `--json` envelope keys (`ok: true`, error `error.code`), and command safety across all read-only commands by default, gating write commands behind `--execute-writes` and outputting structured failure checklists.
+- Support stdin (`--content -`) and file import (`--file <path>`) for `remember`, mutually exclusive with `--content <text>`, with byte-identical payload validation and transmission.
+
+### Changed
+
+- Append server `request_id` to terminal error output when returned in server error responses.
+- Display remaining authorization validity countdown while waiting for authorization in `login` (e.g. `Waiting for authorization... (valid for 9m32s)`).
+- Automatically default to JSON output when stdout is not a TTY (e.g. piped or redirected) unless explicit `--terminal` (`--no-json`, `--plain`) is provided.
+- Merge duplicate usage blocks into a single source of truth, aligning command arguments and eliminating drift between `--help` and command-specific help.
+- Normalize process exit codes across all commands: `0` for success/help/version/valid empty states, `1` for user argument/flag/file validation and 4xx client errors, `2` for missing credentials and 401/403 authentication/authorization errors, and `3` for 5xx server errors, connection refusal, timeouts, and oversize response limits.
+
+## 1.1.19
+
+### Changed
+
+- Route `overview`, `activity`, `ledger-list`, and `ledger-summary` commands to key-authenticated `POST /v1/skill/operations` instead of session-backed `/v1/me/*`.
+- Enforce strict parameter allow-listing and client-side argument mapping for `overview`, `activity`, `ledger-list`, and `ledger-summary` without sending `owner_id` or `user_id`.
+- Preserve 403 authorization rejections without downgrade and clearly prompt for re-authorization to explicitly grant required scopes (`memory:read` / `ledger:read`).
+- Consolidate `SKILL.md` middle section into unified Bundled Command Reference with organized subsections for Direct Memory, Ledger, Diagnostics, Knowledge, and Auth.
+
+### Fixed
+
+- Support `reminders` array in `extractList` for `todo-list` terminal rendering when server returns `{ reminders: [...] }`.
+
+## 1.1.18
+
+### Added
+
+- Add read-only `read` command to retrieve a single memory by ID via `GET /v1/memories/{id}/explain?include_embedding=false` with character-window pagination (`--offset`, `--limit`) and minimal projection.
+- Add write-side `update` command to modify an existing memory via `PATCH /v1/memories/{id}` with `--content`, `--path`, `--metadata`, `--bucket`, and `--scope`.
+- Add write-side `forget` command for soft deletion via `POST /v1/memories/{id}/forget` with mode `soft_delete` and mandatory `--confirm` protection against accidental deletion.
+- Add strictly read-only `ledger-list` command to retrieve personal financial transactions via `GET /v1/me/ledger/transactions` with filtering and local `--month` date-range resolution.
+- Add strictly read-only `ledger-summary` command to aggregate monthly financial totals via `GET /v1/me/ledger/monthly-summary`.
+- Add strictly read-only `overview` command to view personal account metrics (memory counts, storage usage, active agents, tokens) via `GET /v1/me/overview`.
+- Add strictly read-only `activity` command to inspect recent account activity via `GET /v1/me/activity` with optional `--limit`.
+- Add strictly read-only `stats` command to inspect memory statistics and dimensional aggregations via `GET /v1/memories/stats` with strict query filtering and `--top-n` bounds.
+
+### Fixed
+
+- Harmonize `read --json` output envelope with `ok: true`.
+- Replace fallback literal `'v1'` version string in `read` projection with `null` (rendered as `(unknown)` in terminal mode).
+- Pass through server 400 `invalid_memory_id` responses on `update` and default unexpected 400s to `invalid_request`.
+- Display `(unknown)` instead of `0` in `ledger-list` terminal rendering when transaction amount is missing.
+- Preserve all existing command contracts, requests, authentication, scopes, and runtime behavior.
+
+## 1.1.17
+
+- Clarify TODO completion and creation terminal feedback by extracting and
+  displaying confirmed resource IDs on `todo-add` and `todo-done`.
+- Improve `restart-restore` terminal reporting when no active restart snapshot
+  exists to restore.
+- Preserve existing requests, authentication, scopes, service APIs, and all
+  runtime command behavior.
+
+## 1.1.16
+
+- Preserve the read-only `doctor --json` discovery summary when a service omits
+  top-level `service_version`: expose the separately advertised standalone Skill
+  package version without inferring it is a service version.
+- Preserve existing requests, authentication, scopes, service APIs, and all
+  runtime command behavior.
+
+## 1.1.15
+
+- Add explicit read-only Knowledge support to `recall-context` through the
+  opt-in `--include_knowledge true` flag; the default request remains
+  Memory-only for backward compatibility.
+- Request the least-privilege `knowledge:read` scope during new formal Skill
+  device login. Existing credentials are never expanded automatically; use
+  verified reauthorization when Knowledge access is needed.
+- Include `recall-context` in top-level help and document the Knowledge scope,
+  service feature, temporary-token, and untrusted-context boundaries.
+- Tests cover the opt-in request field, strict boolean parsing, login scope,
+  top-level help, and Knowledge authorization documentation.
+
+## 1.1.14
+
+- Align the documented standalone Skill runtime with the MemoryOS Node.js
+  baseline: Node.js 22.22.0 or newer.
+- Keep the runtime behavior, authentication, scopes, service APIs, and package
+  metadata unchanged.
+
+## 1.1.13
+
+- Add the read-only `recall-context` command for the service's bounded,
+  prompt-ready `/v1/recall/context` response, with client-side budget validation.
+- Preserve existing authentication, scopes, temporary-sandbox limits, and all
+  other runtime commands.
+
+## 1.1.12
+
+- Add a short first-successful-run path: anonymous service health check,
+  deliberate credential choice, and credential verification before memory work.
+- Preserve runtime commands, network requests, authentication, scopes,
+  credential behavior, service APIs, and MCP fallback behavior.
+
+## 1.1.11
+
+- Simplify the standalone Skill description so agents can discover its core
+  memory, continuity, TODO, expense, and diagnostics workflows without an
+  exhaustive command list.
+- Preserve the existing runtime commands, authentication, scopes, service
+  requests, and MCP fallback behavior.
+
+## 1.1.10
+
+- Clarify plain-text `doctor` output: an explicit `--anonymous` health check
+  now says authentication was not checked, while a normal no-credential check
+  prints the formal-login next command.
+- Preserve the existing read-only health request, JSON diagnostics, credential
+  lookup, authentication, scope, and degraded-discovery behavior.
+
+## 1.1.9
+
+- Expand the bounded, read-only `doctor --json` discovery summary with the
+  advertised service version, MCP URL, and supported clients so agents can
+  diagnose compatibility without parsing the raw discovery document.
+- Preserve existing anonymous, credential, health-check, and degraded-discovery
+  behavior; the new fields come only from the public discovery response.
+
+## 1.1.8
+
+- Consolidate repeated command examples in `SKILL.md`: document each canonical
+  command once, while retaining `auth-status` as a runtime compatibility alias.
+
+## 1.1.7
+
+- Stop shipping `install.sh` and `install.ps1` inside the published Skill. Their
+  only job is to download this archive, so packaging them within it was circular
+  and left two unused scripts in every install destination. They now live beside
+  the Skill in the source repository and remain available from the published
+  installer endpoints.
+- Skill runtime, commands, credential handling, and network behaviour are
+  unchanged; this release only removes two files that no runtime path used.
+
+## 1.1.6
+
+- Remove repeated standalone-installation links from `SKILL.md`; installation
+  distribution remains owned by the package and release surfaces, while this
+  Skill starts at runtime selection and explicit credential setup.
+
+## 1.1.5
+
+- Add zero-dependency POSIX and PowerShell installers for the published
+  standalone Skill archive. Both enforce HTTPS-only download paths, reject
+  non-HTTPS redirects, verify the bundled runtime entrypoint, and never accept
+  or send XMemo credentials.
+- Document the installer commands and their destination/origin boundaries;
+  installation remains separate from explicit login and credential setup.
+- Regression coverage pins the HTTPS, redirect, entrypoint, and no-token
+  guarantees for both installer scripts.
+
+## 1.1.4
+
+- `scripts/xmemo-skill.mjs`: add a bounded, token-free `clientDiagnostics`
+  block to `doctor --json`, including read-only discovery service/capability
+  summary and a concrete next credential-check or sign-in command.
+- Diagnostics: when discovery is unavailable, report a stable degraded status
+  without failing an otherwise healthy doctor operation or changing any auth,
+  write, or restart-continuity behavior.
+- Tests and Skill documentation: cover authenticated, anonymous, and degraded
+  discovery output while preserving the no-Authorization-header guarantee for
+  `doctor --anonymous`.
+
+## 1.1.3
+
+- `scripts/xmemo-skill.mjs`: report a clear empty-state result when a successful
+  `restore-state` response contains no saved state, while preserving the
+  requested key and an explicit empty-content marker for valid state objects.
+- Tests: cover empty and partially populated state-restore responses so the
+  standalone command does not print `undefined` to users.
+
+## 1.1.2
+
+- `SKILL.md` and references: distinguish the public generic
+  `/v1/skill/operations` discovery list from the formal-account-only direct
+  restart-continuity routes. This prevents a missing restart entry in
+  `standalone_skill.operations` from being misread as an unavailable command.
+- Documentation and tests: clarify that temporary agents never receive restart
+  continuity, that discovery alone is not authorization, and that an
+  unauthenticated `401` is route reachability rather than a write-capability
+  proof.
+
+## 1.1.1
+
+- `scripts/xmemo-skill.mjs`: add formal-account `restart-snapshot` and
+  `restart-restore` commands for the Memory OS v0.4.335 full-continuity
+  contract, without replacing the lightweight `save-state` / `restore-state`
+  workflow or widening temporary-agent permissions.
+- `scripts/xmemo-skill.mjs`: validate restart snapshot limits, TTLs, metadata,
+  and restore booleans; keep normal output bounded to IDs/timestamps while
+  retaining redacted `--json` output for trusted callers.
+- `SKILL.md` and references: explain when to use single-state handoff,
+  full restart continuity, or native MCP restart tools.
+- Tests: pin the advertised runtime version to the newest change-log heading so
+  a released section is never reopened for new work.
+
+## 1.1.0
+
+- `scripts/xmemo-skill.mjs`: align the advertised and runtime version at `1.1.0` while preserving the `XMemo Memory` package identity and formal-account-first login policy.
+- `scripts/xmemo-skill.mjs`: add the discovery-compatible `auth-status` alias and `auth claim-deny` for the server's two-phase temporary-account bind flow.
+- `scripts/xmemo-skill.mjs`: read temporary item/expiry limits from `/.well-known/xmemo-agent.json`, disclose them immediately after registration, and use the documented production limits as a non-blocking fallback when discovery is unavailable.
+- `scripts/xmemo-skill.mjs`: route temporary `search` to `/v1/memories/search`, keep `recall` on `/v1/recall`, and retain temporary access only for `remember`, `recall`, and `search`.
+- `scripts/xmemo-skill.mjs`: parse `--metadata` as a JSON object, parse `--explain` and `--prefer_working` as strict booleans, and validate state `--ttl_seconds` against the hosted `0..604800` contract.
+- `scripts/xmemo-skill.mjs`: retain the established formal device-login scopes, including `ledger:read`; no server API contract or destructive memory command was added.
+- `SKILL.md` and references: document the formal-account default, temporary limits, status alias, bind-denial flow, and typed argument examples without exposing credential values.
+- Tests: cover dynamic temporary limits, temporary search routing, bind denial and pending-token cleanup, typed arguments, the `auth-status` alias, version output, and documentation invariants.
+
+## 1.0.9
+
+- Removed the non-runtime `skill-card.md` file. No user-facing, documentation, or runtime behavior changed in this marketplace release.
+
+## 1.0.8
+
+- `scripts/xmemo-skill.mjs`: advance the standalone runtime to `1.0.8` while preserving the existing REST operations, formal-login flow, temporary sandbox, and explicit plaintext fallback.
+- `scripts/xmemo-skill.mjs`: stop displaying token prefixes and prevent `logout` from revoking an externally managed `XMEMO_KEY` unless `--revoke-environment-token` is explicitly supplied.
+- `scripts/xmemo-skill.mjs`: add `doctor --anonymous`, command-specific login/register/logout help, `--version`, strict command parameter allowlists, required-argument validation, and sensitive command-line option rejection.
+- `scripts/xmemo-skill.mjs`: require HTTPS for remote custom origins while retaining loopback HTTP for local development, warn before authenticated custom-origin requests, and add bounded request timeouts plus an 8 MiB response limit.
+- `scripts/xmemo-skill.mjs`: honor device-login expiry, preserve the established formal-account memory and ledger scope set, redact sensitive fields from every JSON operation response, and sanitize human-readable server content for terminal safety.
+- `SKILL.md` and references: document the compatible logout/anonymous-doctor behavior, timeout and origin boundaries, Node.js requirement, and copyable POSIX/PowerShell token-input examples.
+- Tests: cover anonymous diagnostics, external environment-token logout, token-prefix suppression, unsafe origin and secret-option rejection, timeout/response limits, JSON redaction, the established formal-login scope set, device-login expiry, command help, and version output.
+
+- `scripts/xmemo-skill.mjs`: keep `XMEMO_KEY` as the highest-priority credential source and never copy an environment token into local storage.
+- `scripts/xmemo-skill.mjs`: require explicit `--allow-plaintext` consent before `login`, `auth add`, or temporary registration writes any bearer credential; replace the inaccurate “stored securely” claim with the exact storage path and an unencrypted-storage warning.
+- `scripts/xmemo-skill.mjs`: restrict the XMemo credential directory/file to `0700`/`0600` where POSIX permissions are supported, record consent metadata, and warn when reading a legacy unmarked plaintext credential.
+- `scripts/xmemo-skill.mjs`: minimize temporary credential metadata, redact token-shaped fields from JSON claim/error output, and clear pending confirmation data after handoff.
+- `SKILL.md` and references: document credential precedence, explicit plaintext consent, temporary bind-URL handling, and migration guidance while keeping formal account login recommended.
+
+- `scripts/xmemo-skill.mjs`: add an explicit, policy-gated `register --reason unattended|declined` fallback for the server's unauthenticated agent registration. Formal `login` remains the primary path.
+- `scripts/xmemo-skill.mjs`: persist temporary credentials locally, route their allowed `remember`/`recall`/`search` requests to the temporary REST sandbox, reject unsupported commands clearly, and support claim-status/claim-confirm formal-token handoff.
+- `SKILL.md` and references: document the temporary sandbox limits, required user disclosure, bind URL, and formal-account upgrade path.
+
+- `scripts/xmemo-skill.mjs`: normalize successful list payloads (`result.results`, `result.todos`, or a bare array), so `recall`, `search`, and `todo-list` never call `forEach` on an API wrapper object.
+- `scripts/xmemo-skill.mjs`: extract IDs from object or string results for `remember` and `expense-add`, preventing `[object Object]` output.
+- `scripts/xmemo-skill.mjs`: parse every REST response through one guarded JSON helper. Empty or non-JSON gateway responses now include the HTTP status and a bounded server-response preview.
+- `scripts/xmemo-skill.mjs`: add global and command-level `--help`, clear unknown-command errors, and `--compact` rendering for recall/search.
+- `SKILL.md` and `references/*.md`: make every command relative to the Skill root (`node scripts/xmemo-skill.mjs ...`) and document compact output and help.
+- `test/xmemo-standalone-skill.test.js`: add regression coverage for wrapped list payloads, object IDs, help output, and non-JSON responses.