@totalreclaw/totalreclaw 3.3.12 → 3.3.13-rc.1

package/dist/{llm-client.js → llm/llm-client.js}

@@ -8,7 +8,7 @@
  * Embedding generation has been moved to embedding.ts (local ONNX model via
  * @huggingface/transformers). No API key needed for embeddings.
  */
-import { CONFIG } from './config.js';
+import { CONFIG } from '../config.js';
 // ---------------------------------------------------------------------------
 // Provider mappings
 // ---------------------------------------------------------------------------
@@ -754,4 +754,4 @@ async function chatCompletionAnthropic(config, messages, maxTokens, temperature,
 // see embedding.ts + embedder-loader.ts.
 export { generateEmbedding, getEmbeddingDims, getEmbeddingModelId, configureEmbedder, 
 // 3.3.3-rc.1 (#187): pre-pair bundle prefetch
-prefetchEmbedderBundle, } from './embedding.js';
+prefetchEmbedderBundle, } from '../embedding/embedding.js';

package/dist/{hot-cache-wrapper.js → memory/hot-cache-wrapper.js}

@@ -72,12 +72,12 @@ export class PluginHotCache {
         if (!fs.existsSync(this.cachePath))
             return;
         try {
-            const data = fs.readFileSync(this.cachePath);
-            if (data.length < IV_LENGTH + TAG_LENGTH)
+            const encryptedFile = fs.readFileSync(this.cachePath);
+            if (encryptedFile.length < IV_LENGTH + TAG_LENGTH)
                 return;
-            const iv = data.subarray(0, IV_LENGTH);
-            const tag = data.subarray(IV_LENGTH, IV_LENGTH + TAG_LENGTH);
-            const ciphertext = data.subarray(IV_LENGTH + TAG_LENGTH);
+            const iv = encryptedFile.subarray(0, IV_LENGTH);
+            const tag = encryptedFile.subarray(IV_LENGTH, IV_LENGTH + TAG_LENGTH);
+            const ciphertext = encryptedFile.subarray(IV_LENGTH + TAG_LENGTH);
             const decipher = crypto.createDecipheriv('aes-256-gcm', this.key, iv);
             decipher.setAuthTag(tag);
             const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);

package/dist/{memory-runtime.js → memory/memory-runtime.js}

@@ -64,7 +64,7 @@
 // (no OpenClaw type import) so the plugin compiles without depending on
 // OpenClaw's type package.
 // ---------------------------------------------------------------------------
-import { EXTRACTION_SYSTEM_PROMPT } from './extractor.js';
+import { EXTRACTION_SYSTEM_PROMPT } from '../extraction/extractor.js';
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------

package/dist/{pin.js → memory/pin.js}

@@ -10,11 +10,11 @@
  */
 import crypto from 'node:crypto';
 import { createRequire } from 'node:module';
-import { buildV1ClaimBlob, mapTypeToCategory, readV1Blob, } from './claims-helper.js';
-import { findLoserClaimInDecisionLog, maybeWriteFeedbackForPin, } from './contradiction-sync.js';
-import { isValidMemoryType, V0_TO_V1_TYPE } from './extractor.js';
-import { PROTOBUF_VERSION_V4 } from './subgraph-store.js';
-import { confirmIndexed } from './confirm-indexed.js';
+import { buildV1ClaimBlob, mapTypeToCategory, readV1Blob, } from '../extraction/claims-helper.js';
+import { findLoserClaimInDecisionLog, maybeWriteFeedbackForPin, } from '../contradiction/contradiction-sync.js';
+import { isValidMemoryType, V0_TO_V1_TYPE } from '../extraction/extractor.js';
+import { PROTOBUF_VERSION_V4 } from '../subgraph/subgraph-store.js';
+import { confirmIndexed } from '../subgraph/confirm-indexed.js';
 // Lazy-load WASM core (mirrors claims-helper.ts pattern — plays nicely under
 // both the OpenClaw runtime (CJS-ish tsx) and bare Node ESM used by tests).
 const requireWasm = createRequire(import.meta.url);
@@ -64,9 +64,9 @@ const HUMAN_TO_SHORT = {
 };
 /** Parse a decrypted blob into a canonical mutable Claim + current human status. */
 export function parseBlobForPin(decrypted) {
-    let obj;
+    let parsed;
     try {
-        obj = JSON.parse(decrypted);
+        parsed = JSON.parse(decrypted);
     }
     catch {
         const shortClaim = buildCanonicalObjectFromLegacy(decrypted, {});
@@ -79,15 +79,15 @@ export function parseBlobForPin(decrypted) {
     }
     // v1 payload (plugin v3.0.0+): long-form fields + schema_version "1.x".
     // Preserve the v1 structure so the pin path can emit v1 on output.
-    if (typeof obj.text === 'string' &&
-        typeof obj.type === 'string' &&
-        typeof obj.schema_version === 'string' &&
-        obj.schema_version.startsWith('1.')) {
+    if (typeof parsed.text === 'string' &&
+        typeof parsed.type === 'string' &&
+        typeof parsed.schema_version === 'string' &&
+        parsed.schema_version.startsWith('1.')) {
         const v1 = readV1Blob(decrypted);
         if (v1) {
             // Current status = pinStatus if present, else active.
             const human = v1.pinStatus === 'pinned' ? 'pinned' : 'active';
-            const shortProjection = v1ToShortKeyClaim(obj);
+            const shortProjection = v1ToShortKeyClaim(parsed);
             return {
                 source: {
                     kind: 'v1',
@@ -114,10 +114,10 @@ export function parseBlobForPin(decrypted) {
         // readV1Blob returned null — fall through to v0 path.
     }
     // v0 canonical Claim — short keys present.
-    if (typeof obj.t === 'string' && typeof obj.c === 'string') {
-        const st = typeof obj.st === 'string' ? obj.st : 'a';
+    if (typeof parsed.t === 'string' && typeof parsed.c === 'string') {
+        const st = typeof parsed.st === 'string' ? parsed.st : 'a';
         const human = SHORT_TO_HUMAN[st] ?? 'active';
-        const cloned = JSON.parse(JSON.stringify(obj));
+        const cloned = JSON.parse(JSON.stringify(parsed));
         return {
             source: { kind: 'v0', claim: cloned },
             claim: cloned,
@@ -126,9 +126,9 @@ export function parseBlobForPin(decrypted) {
         };
     }
     // Legacy {text, metadata: {importance: 0-1}} shape.
-    if (typeof obj.text === 'string') {
-        const meta = obj.metadata ?? {};
-        const shortClaim = buildCanonicalObjectFromLegacy(obj.text, meta);
+    if (typeof parsed.text === 'string') {
+        const meta = parsed.metadata ?? {};
+        const shortClaim = buildCanonicalObjectFromLegacy(parsed.text, meta);
         return {
             source: { kind: 'v0', claim: shortClaim },
             claim: shortClaim,

package/dist/{retype-setscope.js → memory/retype-setscope.js}

@@ -29,10 +29,10 @@
  */
 import crypto from 'node:crypto';
 import { createRequire } from 'node:module';
-import { buildV1ClaimBlob, mapTypeToCategory, readV1Blob, } from './claims-helper.js';
-import { isValidMemoryType, VALID_MEMORY_SCOPES, V0_TO_V1_TYPE, } from './extractor.js';
-import { PROTOBUF_VERSION_V4 } from './subgraph-store.js';
-import { confirmIndexed } from './confirm-indexed.js';
+import { buildV1ClaimBlob, mapTypeToCategory, readV1Blob, } from '../extraction/claims-helper.js';
+import { isValidMemoryType, VALID_MEMORY_SCOPES, V0_TO_V1_TYPE, } from '../extraction/extractor.js';
+import { PROTOBUF_VERSION_V4 } from '../subgraph/subgraph-store.js';
+import { confirmIndexed } from '../subgraph/confirm-indexed.js';
 // Lazy-load WASM core — mirrors pin.ts pattern.
 const requireWasm = createRequire(import.meta.url);
 let _wasm = null;
@@ -58,18 +58,18 @@ function encodeFactProtobufLocal(fact, version) {
     return Buffer.from(getWasm().encodeFactProtobuf(json));
 }
 function projectFromDecrypted(decrypted) {
-    let obj;
+    let parsed;
     try {
-        obj = JSON.parse(decrypted);
+        parsed = JSON.parse(decrypted);
     }
     catch {
         return null;
     }
     // v1 blob (schema_version "1.x")
-    if (typeof obj.text === 'string' &&
-        typeof obj.type === 'string' &&
-        typeof obj.schema_version === 'string' &&
-        obj.schema_version.startsWith('1.')) {
+    if (typeof parsed.text === 'string' &&
+        typeof parsed.type === 'string' &&
+        typeof parsed.schema_version === 'string' &&
+        parsed.schema_version.startsWith('1.')) {
         const v1 = readV1Blob(decrypted);
         if (v1) {
             return {
@@ -90,18 +90,18 @@ function projectFromDecrypted(decrypted) {
         }
     }
     // v0 short-key blob — upgrade to v1 shape.
-    if (typeof obj.t === 'string' && typeof obj.c === 'string') {
-        const v0Type = typeof obj.c === 'string' ? obj.c : 'fact';
+    if (typeof parsed.t === 'string' && typeof parsed.c === 'string') {
+        const v0Type = typeof parsed.c === 'string' ? parsed.c : 'fact';
         const v1Type = V0_TO_V1_TYPE[v0Type] ?? 'claim';
-        const imp = typeof obj.i === 'number' ? obj.i : 5;
-        const conf = typeof obj.cf === 'number' ? obj.cf : 0.85;
-        const sa = typeof obj.sa === 'string' ? obj.sa : 'user';
+        const imp = typeof parsed.i === 'number' ? parsed.i : 5;
+        const conf = typeof parsed.cf === 'number' ? parsed.cf : 0.85;
+        const sa = typeof parsed.sa === 'string' ? parsed.sa : 'user';
         const validSource = ['user', 'user-inferred', 'assistant', 'external', 'derived'].includes(sa)
             ? sa
             : 'user';
-        const ea = typeof obj.ea === 'string' ? obj.ea : new Date().toISOString();
-        const entities = Array.isArray(obj.e)
-            ? obj.e
+        const ea = typeof parsed.ea === 'string' ? parsed.ea : new Date().toISOString();
+        const entities = Array.isArray(parsed.e)
+            ? parsed.e
                 .map((e) => {
                 if (!e || typeof e !== 'object')
                     return null;
@@ -116,7 +116,7 @@ function projectFromDecrypted(decrypted) {
                 .filter((e) => e !== null)
             : undefined;
         return {
-            text: typeof obj.t === 'string' ? obj.t : '',
+            text: typeof parsed.t === 'string' ? parsed.t : '',
             type: v1Type,
             source: validSource,
             scope: undefined,

package/dist/{credential-provider.js → pairing/credential-provider.js}

@@ -34,8 +34,8 @@
  *     the source of truth; writing back would split it.
  */
 import fs from 'node:fs';
-import { CONFIG } from './config.js';
-import { loadCredentialsJson, writeCredentialsJson, deleteCredentialsFile, } from './fs-helpers.js';
+import { CONFIG } from '../config.js';
+import { loadCredentialsJson, writeCredentialsJson, deleteCredentialsFile, } from '../fs-helpers.js';
 /**
  * Default provider — delegates to the existing fs-helpers functions.
  * Behavior is identical to direct `loadCredentialsJson` / `writeCredentialsJson`

package/dist/{first-run.js → pairing/first-run.js}

@@ -36,7 +36,7 @@
  *     (`mnemonic`, etc.) are intentionally kept so we do not churn the
  *     crypto code for a copy change.
  */
-import { loadCredentialsJson, extractBootstrapMnemonic } from './fs-helpers.js';
+import { loadCredentialsJson, extractBootstrapMnemonic } from '../fs-helpers.js';
 // ---------------------------------------------------------------------------
 // Canonical copy — single source of truth for the welcome-on-first-run UX.
 // Tests import these constants and assert on exact-match substrings; the

package/dist/{onboarding-cli.js → pairing/onboarding-cli.js}

@@ -43,7 +43,7 @@ import path from 'node:path';
 import readline from 'node:readline/promises';
 import { generateMnemonic, validateMnemonic } from '@scure/bip39';
 import { wordlist } from '@scure/bip39/wordlists/english.js';
-import { writeCredentialsJson, loadCredentialsJson, writeOnboardingState, loadOnboardingState, } from './fs-helpers.js';
+import { writeCredentialsJson, loadCredentialsJson, writeOnboardingState, loadOnboardingState, } from '../fs-helpers.js';
 // ---------------------------------------------------------------------------
 // User-facing strings (centralised so tests can assert on them + localisation
 // has one place to grow into later).
@@ -499,17 +499,17 @@ export async function runNonInteractiveOnboard(inputs) {
             scopeAddress = undefined;
         }
     }
-    const result = {
+    const onboardResult = {
         ok: true,
         action,
         credentials_path: inputs.credentialsPath,
     };
     if (scopeAddress)
-        result.scope_address = scopeAddress;
+        onboardResult.scope_address = scopeAddress;
     if (inputs.emitPhrase)
-        result.mnemonic = mnemonic;
+        onboardResult.mnemonic = mnemonic;
     void state; // Touch for clarity — state is persisted via writeCredsAndState.
-    return result;
+    return onboardResult;
 }
 // ---------------------------------------------------------------------------
 // CLI registration
@@ -642,7 +642,7 @@ export function registerOnboardingCli(program, opts) {
             if (phrase === '-') {
                 phrase = await readAllStdin();
             }
-            const result = await runNonInteractiveOnboard({
+            const onboardResult = await runNonInteractiveOnboard({
                 credentialsPath: opts.credentialsPath,
                 statePath: opts.statePath,
                 mode,
@@ -655,28 +655,28 @@ export function registerOnboardingCli(program, opts) {
                 // the JSON payload is about to include the plaintext phrase.
                 // stderr is intentional: stdout must remain a single
                 // machine-parseable JSON line.
-                if (cliOpts.emitPhrase && result.ok && result.mnemonic) {
+                if (cliOpts.emitPhrase && onboardResult.ok && onboardResult.mnemonic) {
                     process.stderr.write(PHRASE_PRINT_DEPRECATION_WARNING);
                 }
-                process.stdout.write(JSON.stringify(result) + '\n');
+                process.stdout.write(JSON.stringify(onboardResult) + '\n');
             }
             else {
-                if (result.ok) {
-                    if (result.mnemonic) {
+                if (onboardResult.ok) {
+                    if (onboardResult.mnemonic) {
                         process.stderr.write(PHRASE_PRINT_DEPRECATION_WARNING);
                         process.stderr.write('WARNING: --emit-phrase was set. The plaintext recovery phrase was returned.\n' +
                             'For agent-driven flows, prefer reading ~/.totalreclaw/credentials.json directly ' +
                             'in the user\'s terminal instead of echoing the phrase.\n');
                     }
-                    process.stdout.write(`onboarding: ok  action=${result.action}  ` +
-                        (result.scope_address ? `scope_address=${result.scope_address}  ` : '') +
-                        `credentials=${result.credentials_path}\n`);
+                    process.stdout.write(`onboarding: ok  action=${onboardResult.action}  ` +
+                        (onboardResult.scope_address ? `scope_address=${onboardResult.scope_address}  ` : '') +
+                        `credentials=${onboardResult.credentials_path}\n`);
                 }
                 else {
-                    process.stderr.write(`onboarding: ${result.error}: ${result.error_detail ?? ''}\n`);
+                    process.stderr.write(`onboarding: ${onboardResult.error}: ${onboardResult.error_detail ?? ''}\n`);
                 }
             }
-            process.exit(result.ok ? 0 : 1);
+            process.exit(onboardResult.ok ? 0 : 1);
         }
         if (cliOpts.json) {
             process.stderr.write('--json requires --non-interactive. Use: openclaw totalreclaw onboard --non-interactive --json --mode generate\n');
@@ -685,18 +685,18 @@ export function registerOnboardingCli(program, opts) {
         // Interactive path — original 3.2.0 behaviour preserved in full.
         const io = buildDefaultIo();
         try {
-            const result = await runOnboardingWizard({
+            const wizardResult = await runOnboardingWizard({
                 credentialsPath: opts.credentialsPath,
                 statePath: opts.statePath,
                 io,
             });
-            if (result.error) {
-                opts.logger.warn(`onboarding wizard exited with error: ${result.error}`);
+            if (wizardResult.error) {
+                opts.logger.warn(`onboarding wizard exited with error: ${wizardResult.error}`);
                 io.close();
                 process.exit(1);
             }
-            if (result.choice === 'generate' || result.choice === 'import') {
-                opts.logger.info(`onboarding: state=active createdBy=${result.state?.createdBy}`);
+            if (wizardResult.choice === 'generate' || wizardResult.choice === 'import') {
+                opts.logger.info(`onboarding: state=active createdBy=${wizardResult.state?.createdBy}`);
             }
         }
         catch (err) {

package/dist/{pair-cli-relay.js → pairing/pair-cli-relay.js}

@@ -45,12 +45,12 @@
  */
 import { validateMnemonic } from '@scure/bip39';
 import { wordlist } from '@scure/bip39/wordlists/english.js';
-import { loadCredentialsJson, writeCredentialsJson, writeOnboardingState, } from './fs-helpers.js';
+import { loadCredentialsJson, writeCredentialsJson, writeOnboardingState, } from '../fs-helpers.js';
 import { awaitPhraseUpload, openRemotePairSession, } from './pair-remote-client.js';
-import { setRecoveryPhraseOverride } from './config.js';
+import { setRecoveryPhraseOverride } from '../config.js';
 import { encodePng, encodeUnicode } from './pair-qr.js';
-import { deriveKeys, computeAuthKeyHash } from './crypto.js';
-import { createApiClient } from './api-client.js';
+import { deriveKeys, computeAuthKeyHash } from '../crypto/crypto.js';
+import { createApiClient } from '../billing/api-client.js';
 /**
  * Run the relay-mode pair CLI. Mirrors `runPairCli`'s exit-code semantics:
  *   - `completed` (status 0)
@@ -214,7 +214,7 @@ export async function runRelayPairCli(mode, opts) {
             stdout.write(text);
     };
     try {
-        const result = await awaitPhraseUpload(session, {
+        const completion = await awaitPhraseUpload(session, {
             phraseValidator: (p) => validateMnemonic(p, wordlist),
             completePairing: async ({ mnemonic }) => {
                 try {
@@ -239,8 +239,8 @@ export async function runRelayPairCli(mode, opts) {
                         // serves both protocols on the same host.
                         const httpsBase = opts.relayBaseUrl.replace(/^ws/, 'http').replace(/\/+$/, '');
                         const apiClient = createApiClient(httpsBase);
-                        const result = await apiClient.register(authKeyHash, saltHex);
-                        registeredUserId = result.user_id;
+                        const registerResult = await apiClient.register(authKeyHash, saltHex);
+                        registeredUserId = registerResult.user_id;
                         opts.logger.info(`pair-cli (relay): registered user_id=${registeredUserId} (salt + auth-key persisted)`);
                     }
                     catch (regErr) {
@@ -296,12 +296,12 @@ export async function runRelayPairCli(mode, opts) {
             emitStatus('\nCanceled. Pairing session invalidated.\n');
             return { status: 'canceled', sid: session.token };
         }
-        if (result.state === 'active') {
+        if (completion.state === 'active') {
             emitStatus('\nPairing complete. Account is active.\n');
             return { status: 'completed', sid: session.token };
         }
-        emitStatus(`\nPairing failed: ${result.error ?? 'unknown_error'}\n`);
-        return { status: 'error', sid: session.token, error: result.error ?? 'unknown_error' };
+        emitStatus(`\nPairing failed: ${completion.error ?? 'unknown_error'}\n`);
+        return { status: 'error', sid: session.token, error: completion.error ?? 'unknown_error' };
     }
     catch (err) {
         if (canceled) {

package/dist/{pair-crypto.js → pairing/pair-crypto.js}

@@ -14,4 +14,4 @@
  * material and nonces are passed in by callers. See vault-crypto.ts for
  * the implementation.
  */
-export { HKDF_INFO, AEAD_KEY_BYTES, AEAD_NONCE_BYTES, AEAD_TAG_BYTES, X25519_KEY_BYTES, generateGatewayKeypair, derivePublicFromPrivate, computeSharedSecret, deriveSessionKeys, deriveAeadKeyFromEcdh, aeadDecrypt, decryptPairingPayload, aeadEncryptWithSessionKey, encryptPairingPayload, compareSecondaryCodesCT, } from './vault-crypto.js';
+export { HKDF_INFO, AEAD_KEY_BYTES, AEAD_NONCE_BYTES, AEAD_TAG_BYTES, X25519_KEY_BYTES, generateGatewayKeypair, derivePublicFromPrivate, computeSharedSecret, deriveSessionKeys, deriveAeadKeyFromEcdh, aeadDecrypt, decryptPairingPayload, aeadEncryptWithSessionKey, encryptPairingPayload, compareSecondaryCodesCT, } from '../crypto/vault-crypto.js';

package/dist/{pair-http.js → pairing/pair-http.js}

@@ -381,7 +381,7 @@ export function buildPairRoutes(cfg) {
         //    sid/mode for log correlation.
         void (async () => {
             try {
-                const result = await awaitPhraseUpload(session, {
+                const completion = await awaitPhraseUpload(session, {
                     phraseValidator: validate,
                     timeoutMs: cfg.initAwaitTimeoutMs,
                     completePairing: async ({ mnemonic }) => {
@@ -396,11 +396,11 @@ export function buildPairRoutes(cfg) {
                         return cfg.completePairing({ mnemonic, session: sessionLike });
                     },
                 });
-                if (result.state === 'active') {
+                if (completion.state === 'active') {
                     cfg.logger.info(`pair-http /init: session ${redactSid(session.token)} completed in-process; onboarding active`);
                 }
                 else {
-                    cfg.logger.warn(`pair-http /init: session ${redactSid(session.token)} completion non-active: ${result.error ?? 'unknown'}`);
+                    cfg.logger.warn(`pair-http /init: session ${redactSid(session.token)} completion non-active: ${completion.error ?? 'unknown'}`);
                 }
             }
             catch (err) {

package/dist/{pair-remote-client.js → pairing/pair-remote-client.js}

@@ -158,9 +158,9 @@ export async function openRemotePairSession(opts = {}) {
         const text = typeof raw === 'string' ? raw : Buffer.from(raw).toString('utf-8');
         msg = JSON.parse(text);
     }
-    catch {
+    catch (err) {
         safeClose(ws);
-        throw new Error('pair-remote-client: opened frame not valid JSON');
+        throw new Error('pair-remote-client: opened frame not valid JSON', { cause: err });
     }
     if (msg.type === 'error') {
         const errStr = typeof msg.error === 'string' ? msg.error : 'relay_error';
@@ -220,10 +220,10 @@ export async function awaitPhraseUpload(session, opts) {
         const text = typeof raw === 'string' ? raw : Buffer.from(raw).toString('utf-8');
         msg = JSON.parse(text);
     }
-    catch {
+    catch (err) {
         safeSend(ws, { type: 'nack', error: 'bad_json' });
         safeClose(ws);
-        throw new Error('pair-remote-client: forward frame not valid JSON');
+        throw new Error('pair-remote-client: forward frame not valid JSON', { cause: err });
     }
     if (msg.type !== 'forward') {
         safeSend(ws, { type: 'nack', error: 'expected_forward' });
@@ -281,9 +281,9 @@ export async function awaitPhraseUpload(session, opts) {
     }
     // Hand off to the caller-supplied completion handler. Wrapped in try/finally
     // so we always drop our own reference to the mnemonic.
-    let result;
+    let completion;
     try {
-        result = await opts.completePairing({ mnemonic, session });
+        completion = await opts.completePairing({ mnemonic, session });
     }
     catch (err) {
         safeSend(ws, { type: 'nack', error: 'completion_failed' });
@@ -295,14 +295,14 @@ export async function awaitPhraseUpload(session, opts) {
         // rebinding at least drops the reference from this closure.
         mnemonic = '';
     }
-    if (result.state !== 'active') {
-        safeSend(ws, { type: 'nack', error: result.error ?? 'completion_failed' });
+    if (completion.state !== 'active') {
+        safeSend(ws, { type: 'nack', error: completion.error ?? 'completion_failed' });
         safeClose(ws);
-        return result;
+        return completion;
     }
     safeSend(ws, { type: 'ack' });
     safeClose(ws);
-    return result;
+    return completion;
 }
 /**
  * One-shot convenience: open session + await phrase upload + run completion.

package/dist/{pair-session-store.js → pairing/pair-session-store.js}

@@ -428,17 +428,17 @@ export async function updatePairSession(sessionsPath, sid, mutate, now = Date.no
         }
         const current = pruned.file.sessions[idx];
         const next = mutate(current);
-        let result;
+        let mutatedSession;
         if (next === null) {
             pruned.file.sessions.splice(idx, 1);
-            result = null;
+            mutatedSession = null;
         }
         else {
             pruned.file.sessions[idx] = next;
-            result = next;
+            mutatedSession = next;
         }
         writePairSessionsFileSync(sessionsPath, pruned.file);
-        return result;
+        return mutatedSession;
     }
     finally {
         release();

package/dist/runtime/config-schema.js

@@ -0,0 +1,59 @@
+// ---------------------------------------------------------------------------
+// Plugin configSchema — static JSON-schema for the OpenClaw plugin config.
+// Extracted from index.ts; pure data, no runtime state.
+// ---------------------------------------------------------------------------
+export const CONFIG_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        publicUrl: {
+            type: 'string',
+            description: "Public gateway URL for QR pairing (e.g. 'https://gateway.example.com:18789'). Overrides the auto-resolution cascade in buildPairingUrl.",
+        },
+        extraction: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                enabled: {
+                    type: 'boolean',
+                    description: 'Enable/disable auto-extraction (default: true)',
+                },
+                model: {
+                    type: 'string',
+                    description: "Shorthand: override just the extraction model (e.g., 'glm-4.5-flash', 'gpt-4.1-mini'). For a full provider override use extraction.llm.",
+                },
+                interval: {
+                    type: 'number',
+                    description: 'Number of turns between automatic extractions (default: 3)',
+                },
+                maxFactsPerExtraction: {
+                    type: 'number',
+                    description: 'Hard cap on facts extracted per turn (default: 15)',
+                },
+                llm: {
+                    type: 'object',
+                    additionalProperties: false,
+                    description: 'Explicit LLM override block. Highest-priority tier in the extraction-provider cascade. Any subset of provider+apiKey is enough to pin a provider.',
+                    properties: {
+                        provider: {
+                            type: 'string',
+                            description: "Provider name: zai | openai | anthropic | gemini | google | mistral | groq | deepseek | openrouter | xai | together | cerebras.",
+                        },
+                        model: {
+                            type: 'string',
+                            description: 'Explicit model id. If omitted, deriveCheapModel(provider) picks a sensible default.',
+                        },
+                        apiKey: {
+                            type: 'string',
+                            description: 'API key for the selected provider. Required for the override to take effect.',
+                        },
+                        baseUrl: {
+                            type: 'string',
+                            description: 'Override the provider base URL (self-hosted / custom gateway setups).',
+                        },
+                    },
+                },
+            },
+        },
+    },
+};