@xmemo/skill 1.1.25 → 1.1.26

package/LICENSE

@@ -1,21 +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.
+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

@@ -20,7 +20,7 @@ npx @xmemo/skill install
 ## Commands
 
 - `xmemo-skill install`: Install the bundled skill files
-- `xmemo-skill version`: Print the skill version (`1.1.25`)
+- `xmemo-skill version`: Print the skill version (`1.1.26`)
 - `xmemo-skill help`: Display command usage and options
 
 ## Package Integrity

package/bin/install.mjs

@@ -1,251 +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);
-  });
-}
+#!/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

@@ -1,6 +1,6 @@
 {
   "name": "@xmemo/skill",
-  "version": "1.1.25",
+  "version": "1.1.26",
   "description": "Standalone installer and distribution package for the XMemo agent skill.",
   "type": "module",
   "bin": {

package/skill/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## 1.1.26
+
+### Fixed
+
+- Classify HTTP 401 and 403 status codes using whole-number word boundaries, avoiding false-positive authentication error classifications on port numbers and identifiers.
+- Clarified documentation for `ledger-list` in `references/ledger-operations.md` and `SKILL.md` to consistently describe it as a strictly read-only query command, explicitly noting that deleting or voiding a ledger entry is a separate operation requiring explicit confirmation (`forget --id <id> --confirm`) and a delete-capable scope (for example `memory:delete`; see the forget section for the full list).
+- Structured reference links in `SKILL.md` as direct Markdown links with one-line descriptions.
+
+### Changed
+
+- Modularized stdin and file input reading into a dedicated helper module (`scripts/lib/bounded-read.mjs`) with explicit streaming byte counting: capped at `MAX_MEMORY_CONTENT_BYTES` (512 KiB) for memory content and `MAX_STDIN_INPUT_BYTES` (64 KiB) for single-value stdin inputs (`auth add`), with early rejection on stream overflow.
+
 ## 1.1.25
 
 ### Added

package/skill/SKILL.md

@@ -289,9 +289,11 @@ remain limited to `remember`, `recall`, and `search`.
 - `ledger-list` is a strictly read-only query backed by
   `POST /v1/skill/operations` (`operation: "ledger-list"`, requiring
   `ledger:read` scope). It retrieves financial and expense transactions without
-  any write or delete capabilities. There is no separate `ledger-delete` command;
-  to remove or void a transaction, obtain its `id` from `ledger-list` and invoke
-  `forget --id <transaction_id> --confirm`. It accepts `--limit <n>`, `--offset <n>`,
+  any write or delete capabilities; `ledger-list` only reads and lists records.
+  Deleting or voiding a transaction is a separate operation that requires
+  explicit confirmation (`forget --id <id> --confirm`) and a delete-capable
+  scope (for example `memory:delete`; see the forget section for the full list).
+  It accepts `--limit <n>`, `--offset <n>`,
   `--currency <code>`, `--from <date>` (`date_from`), `--to <date>` (`date_to`),
   `--category <name>`, `--min-amount <n>`, `--max-amount <n>`, and `--type <type>`
   (`transaction_type`). As a convenience, `--month <YYYY-MM>` can be specified to
@@ -416,7 +418,11 @@ items, verify the credential scopes first. A valid `memory:read` token alone is
 not proof of Knowledge authorization; do not fall back to a broader token or
 attempt to inspect another user's Knowledge space.
 
-For memory and session workflows, read `references/memory-operations.md`. For ledger accounting and diagnostics, read `references/ledger-operations.md`. For command matrix, output formatting, and exit codes, read `references/runtime-operations.md`. For auth, network, and service diagnosis, read `references/troubleshooting.md`.
+For detailed guides and operational references, see:
+- [memory-operations.md](references/memory-operations.md): Core memory, knowledge context, and continuity workflows.
+- [ledger-operations.md](references/ledger-operations.md): Ledger accounting, financial transactions, and account diagnostics.
+- [runtime-operations.md](references/runtime-operations.md): Command matrix, output safety, JSON envelopes, and exit codes.
+- [troubleshooting.md](references/troubleshooting.md): Auth, network, and service diagnosis and recovery.
 
 ## Exit Codes
 

package/skill/references/ledger-operations.md

@@ -28,7 +28,7 @@ node scripts/xmemo-skill.mjs ledger-list --month 2026-09 --json
 ```
 
 `ledger-list` queries personal financial transactions via `POST /v1/skill/operations` (`operation: "ledger-list"`, requiring `ledger:read` scope).
-This command is strictly read-only and possesses zero write or deletion capabilities. To delete or void a transaction, obtain its `id` from `ledger-list` and invoke `forget --id <transaction_id> --confirm`.
+This command is strictly read-only and possesses zero write or deletion capabilities; `ledger-list` only reads and lists recorded transactions. Deleting or voiding a ledger entry is a separate operation that requires explicit confirmation (`forget --id <id> --confirm`) and a delete-capable scope (for example `memory:delete`; see the forget section for the full list).
 Allowed server arguments:
 - `--limit <n>`: Page limit (default 30, max 100).
 - `--offset <n>`: Pagination offset (default 0).

package/skill/scripts/lib/bounded-read.mjs

@@ -0,0 +1,162 @@
+import fs from 'node:fs/promises';
+import { MAX_MEMORY_CONTENT_BYTES, EXIT_CODE } from './core.mjs';
+import { outputContentTooLarge } from './api.mjs';
+
+// Maximum bounded payload for single-value stdin inputs: 65536 bytes (64 KiB).
+export const MAX_STDIN_INPUT_BYTES = 65536;
+
+/**
+ * Read stdin up to a bounded byte limit (default 64 KiB).
+ * Reading halts and rejects immediately if stdin exceeds maxBytes.
+ *
+ * @param {number} maxBytes - Maximum permitted bytes (default 65536)
+ * @returns {Promise<string>}
+ */
+export function readStdin(maxBytes = MAX_STDIN_INPUT_BYTES) {
+  return new Promise((resolve, reject) => {
+    let totalBytes = 0;
+    const chunks = [];
+    let done = false;
+
+    const cleanup = () => {
+      process.stdin.removeListener('data', onData);
+      process.stdin.removeListener('end', onEnd);
+      process.stdin.removeListener('error', onError);
+    };
+
+    const onData = (chunk) => {
+      if (done) return;
+      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      totalBytes += buf.length;
+      // Explicit byte counter: stop and reject immediately when exceeding maxBytes
+      if (totalBytes > maxBytes) {
+        done = true;
+        cleanup();
+        try { process.stdin.pause(); } catch {}
+        const err = new Error(`Input exceeds maximum limit of ${maxBytes} bytes.`);
+        err.exitCode = EXIT_CODE.USER_ERROR;
+        reject(err);
+        return;
+      }
+      chunks.push(buf);
+    };
+
+    const onEnd = () => {
+      if (done) return;
+      cleanup();
+      resolve(Buffer.concat(chunks).toString('utf8').trim());
+    };
+
+    const onError = (err) => {
+      if (done) return;
+      cleanup();
+      reject(err);
+    };
+
+    process.stdin.on('data', onData).on('end', onEnd).on('error', onError).resume();
+  });
+}
+
+/**
+ * Read memory content from stdin with explicit streaming byte counter.
+ * Reading halts and rejects immediately if stdin exceeds MAX_MEMORY_CONTENT_BYTES (524288 bytes).
+ *
+ * @param {object} options - Command options (json / terminal)
+ * @returns {Promise<string>}
+ */
+export function readStdinContent(options = {}) {
+  return new Promise((resolve, reject) => {
+    // Explicit byte counter: bounded to MAX_MEMORY_CONTENT_BYTES (524288 bytes / 512 KiB)
+    let totalBytes = 0;
+    const chunks = [];
+    let done = false;
+
+    const cleanup = () => {
+      process.stdin.removeListener('data', onData);
+      process.stdin.removeListener('end', onEnd);
+      process.stdin.removeListener('error', onError);
+    };
+
+    const onData = (chunk) => {
+      if (done) return;
+      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      totalBytes += buf.length;
+      // Explicit byte counter check: stop and reject immediately if stream exceeds 524288 bytes
+      if (totalBytes > MAX_MEMORY_CONTENT_BYTES) {
+        done = true;
+        cleanup();
+        try { process.stdin.pause(); } catch {}
+        try { process.stdin.destroy(); } catch {}
+        outputContentTooLarge(`Memory content exceeds maximum limit of ${MAX_MEMORY_CONTENT_BYTES} bytes.`, options);
+        return;
+      }
+      chunks.push(buf);
+    };
+
+    const onEnd = () => {
+      if (done) return;
+      cleanup();
+      resolve(Buffer.concat(chunks).toString('utf8'));
+    };
+
+    const onError = (err) => {
+      if (done) return;
+      cleanup();
+      reject(err);
+    };
+
+    process.stdin.on('data', onData).on('end', onEnd).on('error', onError).resume();
+  });
+}
+
+/**
+ * Read memory content from a regular file with bounded size verification.
+ * Rejects if file exceeds MAX_MEMORY_CONTENT_BYTES (524288 bytes / 512 KiB).
+ *
+ * @param {string} filePath - Path to file
+ * @param {object} options - Command options
+ * @returns {Promise<string|null>}
+ */
+export async function readBoundedFile(filePath, options = {}) {
+  let stats;
+  try {
+    stats = await fs.stat(filePath);
+  } catch (err) {
+    throw new Error(`Failed to read file '${filePath}': ${err.message}`);
+  }
+  if (!stats.isFile()) {
+    throw new Error(`Failed to read file '${filePath}': --file must be a regular file.`);
+  }
+  if (stats.size > MAX_MEMORY_CONTENT_BYTES) {
+    outputContentTooLarge(`File '${filePath}' exceeds maximum limit of ${MAX_MEMORY_CONTENT_BYTES} bytes.`, options);
+    return null;
+  }
+  let handle;
+  try {
+    handle = await fs.open(filePath, 'r');
+  } catch (err) {
+    throw new Error(`Failed to read file '${filePath}': ${err.message}`);
+  }
+  const chunks = [];
+  let totalBytes = 0;
+  const chunkBuf = Buffer.alloc(65536);
+  try {
+    while (true) {
+      const toRead = Math.min(65536, (MAX_MEMORY_CONTENT_BYTES + 1) - totalBytes);
+      const { bytesRead } = await handle.read(chunkBuf, 0, toRead, null);
+      if (bytesRead === 0) break;
+      totalBytes += bytesRead;
+      chunks.push(Buffer.from(chunkBuf.subarray(0, bytesRead)));
+      if (totalBytes > MAX_MEMORY_CONTENT_BYTES) break;
+    }
+  } catch (err) {
+    throw new Error(`Failed to read file '${filePath}': ${err.message}`);
+  } finally {
+    await handle.close();
+  }
+  if (totalBytes > MAX_MEMORY_CONTENT_BYTES) {
+    outputContentTooLarge(`File '${filePath}' exceeds maximum limit of ${MAX_MEMORY_CONTENT_BYTES} bytes.`, options);
+    return null;
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}

package/skill/scripts/lib/cli-input.mjs

@@ -1,9 +1,7 @@
-import fs from 'node:fs/promises';
 import {
   DEFAULT_BASE_URL,
   DEFAULT_TIMEOUT_MS,
   MAX_STATE_TTL_SECONDS,
-  MAX_MEMORY_CONTENT_BYTES,
   COMMAND_FLAGS,
   AUTH_FLAGS,
   parseStrictBoolean,
@@ -11,7 +9,11 @@ import {
   parseIntegerInRange,
   parseJsonObject,
 } from './core.mjs';
-import { outputContentTooLarge } from './api.mjs';
+import {
+  readStdin,
+  readStdinContent,
+  readBoundedFile,
+} from './bounded-read.mjs';
 
 export function isStdoutTty() {
   const env = process.env;
@@ -185,98 +187,18 @@ export function validateCommandInput(command, subcommand, positionals, options,
   }
 }
 
-// Read stdin helper
-export async function readStdin() {
-  return new Promise((resolve) => {
-    let data = '';
-    process.stdin.on('data', (chunk) => { data += chunk; });
-    process.stdin.on('end', () => { resolve(data.trim()); });
-  });
-}
-
-// Read full stdin content helper (exact UTF-8 content without trimming) with byte limit
-export function readStdinContent(options = {}) {
-  return new Promise((resolve, reject) => {
-    let totalBytes = 0;
-    const chunks = [];
-    let done = false;
-    const cleanup = () => {
-      process.stdin.removeListener('data', onData);
-      process.stdin.removeListener('end', onEnd);
-      process.stdin.removeListener('error', onError);
-    };
-    const onData = (chunk) => {
-      if (done) return;
-      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-      totalBytes += buf.length;
-      if (totalBytes > MAX_MEMORY_CONTENT_BYTES) {
-        done = true;
-        cleanup();
-        try { process.stdin.pause(); } catch {}
-        try { process.stdin.destroy(); } catch {}
-        outputContentTooLarge(`Memory content exceeds maximum limit of ${MAX_MEMORY_CONTENT_BYTES} bytes.`, options);
-        return;
-      }
-      chunks.push(buf);
-    };
-    const onEnd = () => {
-      if (done) return;
-      cleanup();
-      resolve(Buffer.concat(chunks).toString('utf8'));
-    };
-    const onError = (err) => {
-      if (done) return;
-      cleanup();
-      reject(err);
-    };
-    process.stdin.on('data', onData).on('end', onEnd).on('error', onError).resume();
-  });
-}
+export {
+  readStdin,
+  readStdinContent,
+  readBoundedFile,
+};
 
 export async function resolveCommandInputs(command, flags, options = {}) {
   if (command === 'remember') {
     if (flags.file !== undefined) {
-      let stats;
-      try {
-        stats = await fs.stat(flags.file);
-      } catch (err) {
-        throw new Error(`Failed to read file '${flags.file}': ${err.message}`);
-      }
-      if (!stats.isFile()) {
-        throw new Error(`Failed to read file '${flags.file}': --file must be a regular file.`);
-      }
-      if (stats.size > MAX_MEMORY_CONTENT_BYTES) {
-        outputContentTooLarge(`File '${flags.file}' exceeds maximum limit of ${MAX_MEMORY_CONTENT_BYTES} bytes.`, options);
-        return;
-      }
-      let handle;
-      try {
-        handle = await fs.open(flags.file, 'r');
-      } catch (err) {
-        throw new Error(`Failed to read file '${flags.file}': ${err.message}`);
-      }
-      const chunks = [];
-      let totalBytes = 0;
-      const chunkBuf = Buffer.alloc(65536);
-      try {
-        while (true) {
-          const toRead = Math.min(65536, (MAX_MEMORY_CONTENT_BYTES + 1) - totalBytes);
-          const { bytesRead } = await handle.read(chunkBuf, 0, toRead, null);
-          if (bytesRead === 0) break;
-          totalBytes += bytesRead;
-          chunks.push(Buffer.from(chunkBuf.subarray(0, bytesRead)));
-          if (totalBytes > MAX_MEMORY_CONTENT_BYTES) break;
-        }
-      } catch (err) {
-        throw new Error(`Failed to read file '${flags.file}': ${err.message}`);
-      } finally {
-        await handle.close();
-      }
-      if (totalBytes > MAX_MEMORY_CONTENT_BYTES) {
-        outputContentTooLarge(`File '${flags.file}' exceeds maximum limit of ${MAX_MEMORY_CONTENT_BYTES} bytes.`, options);
-        return;
-      }
-      flags.content = Buffer.concat(chunks).toString('utf8');
+      const content = await readBoundedFile(flags.file, options);
+      if (content === null) return;
+      flags.content = content;
       delete flags.file;
     } else if (flags.content === '-') {
       flags.content = await readStdinContent(options);

package/skill/scripts/lib/core.mjs

@@ -120,9 +120,8 @@ export function exitCodeForError(err) {
     return EXIT_CODE.SERVER_ERROR;
   }
   if (
-    msg.includes('401') ||
+    /\b40[13]\b/.test(msg) ||
     msg.includes('unauthorized') ||
-    msg.includes('403') ||
     msg.includes('forbidden') ||
     msg.includes('invalid or expired token') ||
     msg.includes('no xmemo credential found') ||

package/skill/scripts/lib/openclaw-egress.mjs

@@ -1,4 +1,4 @@
-import { DEFAULT_BASE_URL } from './core.mjs';
+import { DEFAULT_BASE_URL, EXIT_CODE } from './core.mjs';
 import { isSurrogateToken, assertSurrogateOrigin } from './muse-vault.mjs';
 
 export const OPENCLAW_SENTINEL_REGEX = /^oc-sent-v2\.[A-Za-z0-9_-]+\.end$/;
@@ -32,16 +32,20 @@ export function assertOpenClawEgress(token, targetUrl, env = process.env) {
   if (!isOpenClawSentinel(token)) return;
 
   if (!isProxyEnvActive(env)) {
-    throw new Error(
+    const error = new Error(
       'OpenClaw egress proxy is required when using OpenClaw secrets. Enable secrets.egressProxy.enabled and ensure execution runs in Gateway-hosted exec (HTTPS_PROXY and NODE_USE_ENV_PROXY=1 must be set).'
     );
+    error.exitCode = EXIT_CODE.USER_ERROR;
+    throw error;
   }
 
   const urlObj = typeof targetUrl === 'string' ? new URL(targetUrl) : targetUrl;
   if (urlObj.origin !== ALLOWED_EGRESS_ORIGIN) {
-    throw new Error(
+    const error = new Error(
       `OpenClaw secret sentinels are restricted to ${ALLOWED_EGRESS_ORIGIN} and cannot be sent to ${urlObj.origin}. Unset XMEMO_BASE_URL or use a standard credential.`
     );
+    error.exitCode = EXIT_CODE.USER_ERROR;
+    throw error;
   }
 }
 

package/skill/scripts/xmemo-skill.mjs

@@ -58,7 +58,7 @@ import { handleLedger } from './commands/ledger.mjs';
 import { handleAccount } from './commands/account.mjs';
 import { handleOps } from './commands/ops.mjs';
 
-const SKILL_VERSION = '1.1.25';
+const SKILL_VERSION = '1.1.26';
 
 async function main() {
   let { command, subcommand, positionals, options, flags } = parseArgs(process.argv.slice(2));