@reefclaw/connect 0.1.6 → 0.1.7

package/assets/bridge/bridge.js

@@ -6,7 +6,7 @@ import { join } from 'path';
 import { homedir } from 'os';
 import { logger } from './logger.js';
 import { Connector } from './connector.js';
-import { readLocalSkillVersion, validateSkillContent, compareSemver } from './utils/skill-version.js';
+import { readLocalSkillVersion, readAgentVisibleSkillVersions, validateSkillContent, compareSemver } from './utils/skill-version.js';
 import { verifySkillSignature, signatureRequired, readLastAppliedSignedAtMs, recordAppliedSignedAt, } from './utils/skill-signing.js';
 import { isTradingMode, validateModeTransition, redactTokens } from '@reefclaw/shared';
 import { OPERATOR_WRITE_METHODS } from './types.js';
@@ -837,6 +837,37 @@ export class Bridge {
                     logger.warn(TAG, `Failed to update workspace skill SKILL.md: ${scanErr instanceof Error ? scanErr.message : String(scanErr)}`);
                 }
             }
+            // 2d. Also write to the plugin-extension bundled skill directory — the
+            // chat-channel install layout (`/plugins install clawhub:...`) loads the
+            // agent-visible skill from ~/.openclaw/extensions/<plugin>/skills/, and a
+            // plugin (re)install resets that copy to the bundled bootstrap while the
+            // workspace copy above (our version tracker) survives. Without this
+            // write the agent stays on the bootstrap forever while the pull reports
+            // "already up to date" (observed live 2026-07-11).
+            const extensionsDir = join(homedir(), '.openclaw', 'extensions');
+            if (existsSync(extensionsDir)) {
+                try {
+                    for (const ext of readdirSync(extensionsDir, { withFileTypes: true })) {
+                        if (!ext.isDirectory() || !ext.name.includes('reefclaw'))
+                            continue;
+                        const extSkillsDir = join(extensionsDir, ext.name, 'skills');
+                        if (!existsSync(extSkillsDir))
+                            continue;
+                        for (const skillEntry of readdirSync(extSkillsDir, { withFileTypes: true })) {
+                            if (!skillEntry.isDirectory() || !skillEntry.name.includes('reefclaw'))
+                                continue;
+                            const extSkillMd = join(extSkillsDir, skillEntry.name, 'SKILL.md');
+                            if (existsSync(extSkillMd)) {
+                                writeFileSync(extSkillMd, content, 'utf-8');
+                                logger.info(TAG, `Updated extension skill SKILL.md: ${extSkillMd}`);
+                            }
+                        }
+                    }
+                }
+                catch (scanErr) {
+                    logger.warn(TAG, `Failed to update extension skill SKILL.md: ${scanErr instanceof Error ? scanErr.message : String(scanErr)}`);
+                }
+            }
             // 3. Invalidate skillsSnapshot cache WITHOUT wiping sessions.json
             // Previously we wrote '{}' to sessions.json which destroyed OpenClaw chat history.
             // Now we surgically remove only the skillsSnapshot key from each session entry,
@@ -979,12 +1010,24 @@ export class Bridge {
                 return;
             }
             this.currentSkillVersion = readLocalSkillVersion();
-            if (compareSemver(body.version, this.currentSkillVersion) <= 0) {
+            // The workspace tracker alone is NOT proof the agent has the full skill:
+            // a plugin (re)install resets the agent-visible extension copy to the
+            // bundled bootstrap while the workspace copy survives (observed live
+            // 2026-07-11 — agent stranded on 0.0.5 with the tracker at 2.20.4). If
+            // ANY agent-visible copy is behind the webapp version, re-apply anyway;
+            // applySkillUpdate is idempotent across all copies.
+            const staleAgentCopies = readAgentVisibleSkillVersions().filter((v) => compareSemver(body.version, v) > 0);
+            if (compareSemver(body.version, this.currentSkillVersion) <= 0 && staleAgentCopies.length === 0) {
                 logger.info(TAG, `SKILL.md webapp pull: local v${this.currentSkillVersion ?? 'unknown'} already >= webapp v${body.version} — nothing to do`);
                 this.skillPullInFlight = false;
                 return;
             }
-            logger.info(TAG, `SKILL.md webapp pull: local v${this.currentSkillVersion ?? 'unknown'} behind webapp v${body.version} — applying`);
+            if (staleAgentCopies.length > 0 && compareSemver(body.version, this.currentSkillVersion) <= 0) {
+                logger.info(TAG, `SKILL.md webapp pull: agent-visible skill copy at v${staleAgentCopies[0]} behind webapp v${body.version} (plugin reinstall reset it) — re-applying`);
+            }
+            else {
+                logger.info(TAG, `SKILL.md webapp pull: local v${this.currentSkillVersion ?? 'unknown'} behind webapp v${body.version} — applying`);
+            }
             const result = await this.applySkillUpdate({ version: body.version, content: body.content });
             this.emit('agent_state', 'skill_update_applied', {
                 event: 'skill_update_applied',

package/assets/bridge/utils/skill-version.d.ts

@@ -2,6 +2,15 @@
 export declare function parseSkillVersion(content: string): string | null;
 /** Read current SKILL.md version from disk */
 export declare function readLocalSkillVersion(): string | null;
+/** Versions of the AGENT-VISIBLE reefclaw SKILL.md copies under the
+ *  plugin-extension layout (`~/.openclaw/extensions/<plugin>/skills/<skill>/`)
+ *  — what OpenClaw's skill loader actually reads on chat-channel installs.
+ *  A plugin (re)install resets these to the bundled bootstrap while the
+ *  workspace copy (the version tracker above) survives, so the tracker alone
+ *  cannot be trusted for "already up to date" (observed live 2026-07-11: agent
+ *  stranded on bootstrap 0.0.5 while the tracker read 2.20.4). Fail-soft:
+ *  unreadable dirs/files are skipped; no extensions dir → empty list. */
+export declare function readAgentVisibleSkillVersions(): string[];
 /**
  * Compare two semver strings.
  * Returns 1 if a > b, -1 if a < b, 0 if equal.

package/assets/bridge/utils/skill-version.js

@@ -1,5 +1,5 @@
 // SKILL.md version parsing utility for OTA updates
-import { readFileSync } from 'fs';
+import { readFileSync, readdirSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 const SKILL_MD_PATH = join(homedir(), '.openclaw', 'workspace', 'SKILL.md');
@@ -18,6 +18,50 @@ export function readLocalSkillVersion() {
         return null;
     }
 }
+/** Versions of the AGENT-VISIBLE reefclaw SKILL.md copies under the
+ *  plugin-extension layout (`~/.openclaw/extensions/<plugin>/skills/<skill>/`)
+ *  — what OpenClaw's skill loader actually reads on chat-channel installs.
+ *  A plugin (re)install resets these to the bundled bootstrap while the
+ *  workspace copy (the version tracker above) survives, so the tracker alone
+ *  cannot be trusted for "already up to date" (observed live 2026-07-11: agent
+ *  stranded on bootstrap 0.0.5 while the tracker read 2.20.4). Fail-soft:
+ *  unreadable dirs/files are skipped; no extensions dir → empty list. */
+export function readAgentVisibleSkillVersions() {
+    const versions = [];
+    const extensionsDir = join(homedir(), '.openclaw', 'extensions');
+    let extEntries;
+    try {
+        extEntries = readdirSync(extensionsDir, { withFileTypes: true });
+    }
+    catch {
+        return versions;
+    }
+    for (const ext of extEntries) {
+        if (!ext.isDirectory() || !ext.name.includes('reefclaw'))
+            continue;
+        const skillsDir = join(extensionsDir, ext.name, 'skills');
+        let skillEntries;
+        try {
+            skillEntries = readdirSync(skillsDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const s of skillEntries) {
+            if (!s.isDirectory() || !s.name.includes('reefclaw'))
+                continue;
+            try {
+                const v = parseSkillVersion(readFileSync(join(skillsDir, s.name, 'SKILL.md'), 'utf-8'));
+                if (v)
+                    versions.push(v);
+            }
+            catch {
+                // unreadable/absent copy — nothing to report for this entry
+            }
+        }
+    }
+    return versions;
+}
 // 120KB — the full SKILL.md crossed 100KB at v2.20.0 (103.7KB), which silently
 // broke every OTA apply against the old 100KB cap. Keep comfortably under the
 // 128KiB Cloudflare Durable-Object per-value hard limit the relay stores into.

package/assets/plugin/ccxt/binance-ban-gate.js

@@ -128,6 +128,8 @@ const CONTEXT_WEIGHT = {
     fetchOHLCV: 2,
     fetchFundingRate: 1,
     fetchOpenInterest: 1,
+    // Readiness gate's host→Binance reachability probe (fapiPublicGetTime, wt 1).
+    reachabilityProbe: 1,
     // ExchangeInfoCache boot load — ccxt loadMarkets() → GET /fapi/v1/exchangeInfo,
     // IP weight 1 (doc-verified developers.binance.com 2026-07-10). Was the
     // known "ungated_ip" ccxt-internal call named in the window-summary comment.
@@ -200,7 +202,7 @@ const NEVER_PACE = new Set([
 const SHED_FIRST = new Set([
     'fetchTodayIncomeBreakdown', 'fetchTransfers', 'fetchRecentTradedSymbols',
     'fetchTicker', 'fetchTickerRaw', 'fetchOHLCV', 'fetchOrderBook',
-    'fetchFundingRate', 'fetchOpenInterest',
+    'fetchFundingRate', 'fetchOpenInterest', 'reachabilityProbe',
 ]);
 let weightWindowStart = 0;
 let weightUsed = 0;

package/assets/plugin/ccxt/binance-public.d.ts

@@ -15,4 +15,19 @@ export declare class BinancePublicApi {
     fetchOrderBook(symbol: string, limit?: number): Promise<OrderBookDepth | null>;
     /** Fetch OHLCV candles. Returns null on error. */
     fetchOHLCV(symbol: string, timeframe?: string, limit?: number): Promise<CcxtOHLCV[] | null>;
+    /** Probe Binance USD-M FUTURES reachability from this host — the readiness
+     *  gate's core signal. Calls the futures-explicit implicit method so it hits
+     *  `fapi.binance.com` (a bare `fetchTime()` on this instance resolves to spot
+     *  `api.binance.com`, since the public client doesn't set defaultType:'future').
+     *  HTTP 451 = Binance geo-restriction; the ban gate does NOT classify 451, so
+     *  we inspect the message here. Ban-gate compliant (assertNotBanned/noteSuccess/
+     *  noteBinanceError). Outcomes:
+     *   - 'reachable'   clean response (driftMs = serverTime − localTime)
+     *   - 'geo_blocked' HTTP 451 — host is in a restricted region (actionable)
+     *   - 'unknown'     the ban/weight gate paused us — NOT a host problem
+     *   - 'unreachable' network / DNS / timeout / other error */
+    probeReachability(): Promise<{
+        outcome: 'reachable' | 'geo_blocked' | 'unreachable' | 'unknown';
+        driftMs: number | null;
+    }>;
 }

package/assets/plugin/ccxt/binance-public.js

@@ -2,7 +2,7 @@
 // No API keys required — only uses public market data.
 import { createRequire } from 'node:module';
 import { logger } from '../logger.js';
-import { assertNotBanned, noteBinanceError, noteSuccess } from './binance-ban-gate.js';
+import { assertNotBanned, noteBinanceError, noteSuccess, BinanceBannedError } from './binance-ban-gate.js';
 const TAG = 'binance-public';
 // Load ccxt via CJS require — OpenClaw's ESM loader gives wrong module shape
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -144,4 +144,37 @@ export class BinancePublicApi {
             return null;
         }
     }
+    /** Probe Binance USD-M FUTURES reachability from this host — the readiness
+     *  gate's core signal. Calls the futures-explicit implicit method so it hits
+     *  `fapi.binance.com` (a bare `fetchTime()` on this instance resolves to spot
+     *  `api.binance.com`, since the public client doesn't set defaultType:'future').
+     *  HTTP 451 = Binance geo-restriction; the ban gate does NOT classify 451, so
+     *  we inspect the message here. Ban-gate compliant (assertNotBanned/noteSuccess/
+     *  noteBinanceError). Outcomes:
+     *   - 'reachable'   clean response (driftMs = serverTime − localTime)
+     *   - 'geo_blocked' HTTP 451 — host is in a restricted region (actionable)
+     *   - 'unknown'     the ban/weight gate paused us — NOT a host problem
+     *   - 'unreachable' network / DNS / timeout / other error */
+    async probeReachability() {
+        try {
+            assertNotBanned('reachabilityProbe');
+            const r = await this.exchange.fapiPublicGetTime({});
+            noteSuccess();
+            const serverTime = Number(r?.serverTime);
+            const driftMs = Number.isFinite(serverTime) ? serverTime - Date.now() : null;
+            return { outcome: 'reachable', driftMs };
+        }
+        catch (err) {
+            noteBinanceError(err);
+            if (err instanceof BinanceBannedError) {
+                // Gate paused us (418/429 backoff or weight pacer) — we didn't actually
+                // reach the host, so the result is UNKNOWN, not a reachability failure.
+                return { outcome: 'unknown', driftMs: null };
+            }
+            const msg = err instanceof Error ? err.message : String(err);
+            const geo = msg.includes('451');
+            logger.warn(TAG, `probeReachability failed${geo ? ' (HTTP 451 geo-block)' : ''}: ${msg}`);
+            return { outcome: geo ? 'geo_blocked' : 'unreachable', driftMs: null };
+        }
+    }
 }

package/assets/plugin/index.js

@@ -29,6 +29,7 @@ import { PositionStateStore } from './live/position-state-store.js';
 import { PendingEntryStore } from './ingest/pending-entry-metadata.js';
 import { onReconcilerObservedClose, reconcileStateStoreOnStartup } from './ingest/reconciler-cleanup.js';
 import { reconcileDbOpenVsExchange } from './ingest/reconcile-db-vs-exchange.js';
+import { startReadinessReporter } from './ingest/readiness-reporter.js';
 import { IntelMicrostructureAssembler } from './live/microstructure-assembler.js';
 import { recordPositionReviewsTool } from './tools/record-position-reviews.js';
 import { getMyRecentReviewsTool } from './tools/get-my-recent-reviews.js';
@@ -2020,6 +2021,19 @@ const paperTradingPlugin = {
         pluginToolNames = toolNames;
         pluginInitialised = true;
         logger.info(TAG, `Registered ${gatedTools.length} tools (gate mode=${toolGate.getMode()}): ${toolNames.join(', ')}. Plugin v3.8.0 (${runtime.mode} mode)`);
+        // Agent-readiness reporter (docs/AGENT_READINESS_GATE_PLAN.md Phase 1):
+        // probe host→Binance reachability (HTTP 451 geo-block) + clock drift on the
+        // host and POST a plain-English report to the webapp, so a silently-broken
+        // agent shows an actionable dashboard alert instead of a false green.
+        // Advisory + fire-and-forget; no token → no-op. Runs here once (guarded by
+        // the pluginInitialised early-return → once per process) + on an unref'd
+        // interval inside the reporter.
+        startReadinessReporter({
+            apiBaseUrl,
+            token: resolveIngestToken({ connectionToken }),
+            binanceApi,
+            toolCount: toolNames.length,
+        });
         maybeStartConnectorSupervisor();
     },
 };

package/assets/shared/index.d.ts

@@ -8,3 +8,5 @@ export type { FillEvent, FillSource } from './fills.js';
 export { redactTokens, redactTokensInPayload, REDACTED_TOKEN } from './redact.js';
 export type { Direction, OhlcvBar, TradeFlowBucket, GlobalMarketContext, MarketContext, SignalCondition, StrategyEvaluation, StrategyDefinition, SignalEvent, StrategyState, SignalSnapshot, } from './signals/types.js';
 export type { ConditionResult, ConditionContext, ConditionFn, ConditionConfig, EntryRuleConfig, StopRuleConfig, DirectionRule, PrimaryTimeframe, StrategyConfig, } from './signals/conditions/types.js';
+export type { ReadinessStatus, ReadinessPhase, ReadinessCheckId, ReadinessCheck, ReadinessReport, } from './readiness.js';
+export { READINESS_CHECK_COPY, makeReadinessCheck, deriveOverallReadiness, } from './readiness.js';

package/assets/shared/index.js

@@ -3,3 +3,4 @@ export { VALID_CHANNELS, VALID_EMERGENCY_ACTIONS } from './protocol.js';
 export { logger, setLogLevel, formatError } from './logger.js';
 export { VALID_TRADING_MODES, isTradingMode, validateModeTransition, modeRequiresCredentials, } from './trading-mode.js';
 export { redactTokens, redactTokensInPayload, REDACTED_TOKEN } from './redact.js';
+export { READINESS_CHECK_COPY, makeReadinessCheck, deriveOverallReadiness, } from './readiness.js';

package/assets/skill/SKILL.md

@@ -39,6 +39,12 @@ You are being connected to **ReefClaw**, a supervised trading control room. Your
 
 **Do not attempt to trade before the full instructions arrive.** If trading tools are visible but this file is still a bootstrap version (0.0.x), the connection has not completed — finish connecting first.
 
+## Host requirements (check before connecting)
+
+ReefClaw trades on Binance USD-M Futures, so **the machine running this OpenClaw must be able to reach Binance** (`fapi.binance.com`). Binance geo-restricts many locations: cheap US cloud regions — and some other jurisdictions — return **HTTP 451** ("restricted location"), and the agent then cannot fetch market data or trade. This applies even in **paper mode**, which uses live Binance prices.
+
+If your market-data calls fail with `451`, this host is geo-blocked — move the agent to a Binance-permitted region (most EU and several Asia VPS regions work). This is a hosting requirement; ReefClaw cannot configure around it.
+
 ## Connecting (first run) — saving the connect message
 
 The onboarding page at [reefclaw.com/onboarding](https://reefclaw.com/onboarding) gives the user a single **connect message** that carries THREE fields:

package/dist/cli.js

@@ -11,12 +11,28 @@ import { installPlugin } from './plugin.js';
 import { installBridge } from './bridge.js';
 import { installSkill } from './skill.js';
 import { enableConnectorSupervisor } from './supervisor-config.js';
-import { checkGateway } from './validate.js';
+import { checkGateway, checkBinanceRegion } from './validate.js';
 import { readConfig, writeConfig, mergeReefClawConfig, gatewayAuthDowngradeNeeded, openClawInstalled, openClawConfigPath, readGatewayPort, } from './openclaw.js';
 import { run, which } from './exec.js';
 import { step, ok, info, warn, fail, banner, bold, green, cyan, dim } from './ui.js';
 const DASHBOARD = 'https://www.reefclaw.com/dashboard';
 const ONBOARDING = 'https://www.reefclaw.com/onboarding';
+const OPENCLAW_FLOOR = [2026, 6, 0];
+/** Parse a `2026.6.11`-style version out of `openclaw --version` output. */
+function parseOpenClawVersion(out) {
+    const m = out.match(/(\d{4})\.(\d+)\.(\d+)/);
+    return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+}
+/** True when `v` >= `floor` (calendar-semver tuple compare). */
+function meetsFloor(v, floor) {
+    for (let i = 0; i < 3; i += 1) {
+        if (v[i] > floor[i])
+            return true;
+        if (v[i] < floor[i])
+            return false;
+    }
+    return true;
+}
 function preflight() {
     const major = Number(process.versions.node.split('.')[0]);
     if (Number.isFinite(major) && major < 20) {
@@ -29,6 +45,18 @@ function preflight() {
         info(`(If your config lives elsewhere, set OPENCLAW_CONFIG_PATH. Looked at: ${openClawConfigPath()})`);
         process.exit(1);
     }
+    // OpenClaw must be new enough to load the plugin. 2026.4's install scanner
+    // hard-blocks the plugin and its plugin-API floor is below ours (>=2026.6.0),
+    // so proceeding would only fail cryptically at install time. Fail fast — but
+    // ONLY on a version we could parse and confirm is too old; a missing CLI or
+    // unrecognised output stays out of the way (the loader still guards it).
+    const verOut = which('openclaw') ? run('openclaw', ['--version'], { timeoutMs: 10_000 }) : null;
+    const parsed = verOut?.ok ? parseOpenClawVersion(verOut.stdout) : null;
+    if (parsed && !meetsFloor(parsed, OPENCLAW_FLOOR)) {
+        fail(`OpenClaw ${parsed.join('.')} is too old — ReefClaw needs ${OPENCLAW_FLOOR.join('.')} or newer.`);
+        info('Update OpenClaw, then re-run: npm i -g openclaw@latest');
+        process.exit(1);
+    }
 }
 /** Re-write openclaw.json: preserve the user's existing config, overlay the
  *  ENTIRE plugins section the link wrote (the link can wipe other sections, so
@@ -91,6 +119,10 @@ function nextSteps() {
 async function main() {
     banner(bold(cyan('ReefClaw connect')) + dim('  — link your OpenClaw agent to ReefClaw (paper trading)'));
     preflight();
+    // Prevention: a host in a Binance-restricted region (HTTP 451) can't trade —
+    // not even paper, which uses live Binance prices. Advisory (never fatal); the
+    // dashboard readiness surface re-checks it live after connect.
+    const binanceReachable = await checkBinanceRegion();
     const pre = readConfig();
     const plugin = installPlugin();
     const merged = wireConfig(pre);
@@ -115,6 +147,9 @@ async function main() {
     if (!supervised) {
         warn('Connector supervision was not enabled — see the message above to finish it.');
     }
+    if (!binanceReachable) {
+        warn('This host looks geo-blocked by Binance (HTTP 451) — trading will not work until you run the agent from a Binance-permitted region (most EU / several Asia VPS regions).');
+    }
     nextSteps();
 }
 main().catch((err) => {

package/dist/validate.js

@@ -1,7 +1,7 @@
 // Light post-install checks. We can only verify the LOCAL gateway here — the
 // relay handshake only succeeds once the user pastes their connect message
 // (that's the onboarding "auto-detect" step on the dashboard).
-import { step, ok, warn, info } from './ui.js';
+import { step, ok, warn, info, fail } from './ui.js';
 /** Any HTTP response from the local gateway means OpenClaw is up and reachable.
  *  A connection refused means OpenClaw isn't running. */
 export async function checkGateway(port) {
@@ -26,3 +26,35 @@ export async function checkGateway(port) {
         clearTimeout(t);
     }
 }
+/** Probe whether Binance USD-M Futures is reachable from THIS host. A `451` is
+ *  Binance's geo-restriction signal — the host's region is blocked, and trading
+ *  (even paper mode, which uses live Binance prices) cannot work from here. The
+ *  probe is advisory: only a definitive `451` returns false; a network hiccup /
+ *  timeout is NOT a geo-block, so we stay out of the way and let the dashboard
+ *  readiness surface confirm a real, persistent problem later. Never fatal. */
+export async function checkBinanceRegion() {
+    step('Checking Binance reachability from this host');
+    const url = 'https://fapi.binance.com/fapi/v1/ping';
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), 5000);
+    try {
+        const res = await fetch(url, { signal: ctrl.signal });
+        if (res.status === 451) {
+            fail('Binance returned HTTP 451 — this host is in a Binance-restricted region.');
+            info('Trading (and paper mode, which uses live Binance prices) cannot work from here.');
+            info('Run the agent from a Binance-permitted region — most EU / several Asia VPS regions work.');
+            return false;
+        }
+        ok('Binance is reachable from this host');
+        return true;
+    }
+    catch {
+        // DNS / timeout / transient network — not a definitive geo-block. Don't
+        // block the install on a flaky probe.
+        info('Could not probe Binance reachability (network hiccup) — skipping; the dashboard verifies it after connect.');
+        return true;
+    }
+    finally {
+        clearTimeout(t);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reefclaw/connect",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "One-command installer that connects your OpenClaw agent to ReefClaw (paper trading, no exchange keys).",
   "type": "module",
   "bin": {

package/assets/shared/signals/indicators-extended.d.ts

@@ -1,52 +0,0 @@
-export interface OhlcvInput {
-    open: number;
-    high: number;
-    low: number;
-    close: number;
-    volume: number;
-}
-export interface MACDResult {
-    line: number;
-    signal: number;
-    histogram: number;
-    crossover: 'bullish' | 'bearish' | 'none';
-}
-export interface BollingerResult {
-    upper: number;
-    middle: number;
-    lower: number;
-    bandwidth: number;
-    percentB: number;
-}
-export interface StochRSIResult {
-    k: number;
-    d: number;
-}
-export interface IchimokuResult {
-    tenkan: number;
-    kijun: number;
-    senkouA: number;
-    senkouB: number;
-    chikou: number;
-    cloudPosition: 'above' | 'below' | 'inside';
-}
-export interface SupertrendResult {
-    value: number;
-    direction: 'bullish' | 'bearish';
-}
-export declare function computeMACD(closes: number[], fast?: number, slow?: number, signal?: number): MACDResult;
-export declare function computeBollingerBands(closes: number[], period?: number, stdDev?: number): BollingerResult;
-export declare function computeVWAP(bars: OhlcvInput[]): number;
-export declare function computeStochRSI(closes: number[], rsiPeriod?: number, stochPeriod?: number, kSmooth?: number, dSmooth?: number): StochRSIResult;
-export declare function computeADX(highs: number[], lows: number[], closes: number[], period?: number): {
-    adx: number;
-    plusDI: number;
-    minusDI: number;
-};
-export declare function computeIchimoku(highs: number[], lows: number[], closes: number[], tenkanPeriod?: number, kijunPeriod?: number, senkouBPeriod?: number): IchimokuResult;
-export declare function computeOBV(closes: number[], volumes: number[]): {
-    obv: number;
-    slope: 'rising' | 'falling' | 'flat';
-};
-export declare function computeSupertrend(highs: number[], lows: number[], closes: number[], period?: number, multiplier?: number): SupertrendResult;
-export declare function computeWilliamsR(highs: number[], lows: number[], closes: number[], period?: number): number;

package/assets/shared/signals/indicators-extended.js

@@ -1,284 +0,0 @@
-// Extended indicator computations for Phase 13 — Expanded Indicators.
-// Wraps technicalindicators library + custom implementations.
-// All functions take OHLCV arrays (oldest first) and return latest values.
-import { computeATRSeries, computeRSI, mean, computeStd } from './indicators.js';
-// ─── MACD (12, 26, 9) ──────────────────────────────────────────────────
-export function computeMACD(closes, fast = 12, slow = 26, signal = 9) {
-    if (closes.length < slow + signal) {
-        return { line: 0, signal: 0, histogram: 0, crossover: 'none' };
-    }
-    // Compute full EMA series (both aligned to start at index `slow - 1`)
-    const emaFastSeries = emaSeries(closes, fast);
-    const emaSlowSeries = emaSeries(closes, slow);
-    // Align: fast series starts earlier, so take the tail matching slow series length
-    const offset = emaFastSeries.length - emaSlowSeries.length;
-    const macdLine = [];
-    for (let i = 0; i < emaSlowSeries.length; i++) {
-        macdLine.push(emaFastSeries[i + offset] - emaSlowSeries[i]);
-    }
-    // Signal line = EMA of MACD line
-    const signalSeries = emaSeries(macdLine, signal);
-    const sigOffset = macdLine.length - signalSeries.length;
-    const currentLine = macdLine[macdLine.length - 1];
-    const currentSignal = signalSeries[signalSeries.length - 1];
-    const prevLine = macdLine.length >= 2 ? macdLine[macdLine.length - 2] : currentLine;
-    const prevSignalIdx = signalSeries.length >= 2 ? signalSeries.length - 2 : signalSeries.length - 1;
-    const prevSignal = signalSeries[prevSignalIdx];
-    let crossover = 'none';
-    if (prevLine <= prevSignal && currentLine > currentSignal)
-        crossover = 'bullish';
-    else if (prevLine >= prevSignal && currentLine < currentSignal)
-        crossover = 'bearish';
-    return {
-        line: currentLine,
-        signal: currentSignal,
-        histogram: currentLine - currentSignal,
-        crossover,
-    };
-}
-// ─── Bollinger Bands (20, 2σ) ───────────────────────────────────────────
-export function computeBollingerBands(closes, period = 20, stdDev = 2) {
-    if (closes.length < period) {
-        const p = closes[closes.length - 1] ?? 0;
-        return { upper: p, middle: p, lower: p, bandwidth: 0, percentB: 0.5 };
-    }
-    const slice = closes.slice(-period);
-    const middle = mean(slice);
-    const std = computeStd(slice);
-    const upper = middle + stdDev * std;
-    const lower = middle - stdDev * std;
-    const bandwidth = middle > 0 ? ((upper - lower) / middle) * 100 : 0;
-    const price = closes[closes.length - 1];
-    const percentB = upper !== lower ? (price - lower) / (upper - lower) : 0.5;
-    return { upper, middle, lower, bandwidth, percentB };
-}
-// ─── VWAP ───────────────────────────────────────────────────────────────
-export function computeVWAP(bars) {
-    if (bars.length === 0)
-        return 0;
-    let cumVolume = 0;
-    let cumTPxVol = 0;
-    for (const bar of bars) {
-        const tp = (bar.high + bar.low + bar.close) / 3;
-        cumVolume += bar.volume;
-        cumTPxVol += tp * bar.volume;
-    }
-    return cumVolume > 0 ? cumTPxVol / cumVolume : bars[bars.length - 1].close;
-}
-// ─── Stochastic RSI (14, 14, 3, 3) ─────────────────────────────────────
-export function computeStochRSI(closes, rsiPeriod = 14, stochPeriod = 14, kSmooth = 3, dSmooth = 3) {
-    if (closes.length < rsiPeriod + stochPeriod + dSmooth) {
-        return { k: 50, d: 50 };
-    }
-    // Compute RSI series
-    const rsiValues = [];
-    for (let i = rsiPeriod + 1; i <= closes.length; i++) {
-        rsiValues.push(computeRSI(closes.slice(0, i), rsiPeriod));
-    }
-    if (rsiValues.length < stochPeriod)
-        return { k: 50, d: 50 };
-    // Stochastic of RSI
-    const rawK = [];
-    for (let i = stochPeriod - 1; i < rsiValues.length; i++) {
-        const window = rsiValues.slice(i - stochPeriod + 1, i + 1);
-        const min = Math.min(...window);
-        const max = Math.max(...window);
-        rawK.push(max !== min ? ((rsiValues[i] - min) / (max - min)) * 100 : 50);
-    }
-    // %K = SMA of raw stochastic
-    const kValues = sma(rawK, kSmooth);
-    // %D = SMA of %K
-    const dValues = sma(kValues, dSmooth);
-    return {
-        k: Math.round(kValues[kValues.length - 1] ?? 50),
-        d: Math.round(dValues[dValues.length - 1] ?? 50),
-    };
-}
-// ─── ADX (14) ───────────────────────────────────────────────────────────
-export function computeADX(highs, lows, closes, period = 14) {
-    if (highs.length < period * 2 + 1) {
-        return { adx: 0, plusDI: 0, minusDI: 0 };
-    }
-    const plusDM = [];
-    const minusDM = [];
-    const tr = [];
-    for (let i = 1; i < highs.length; i++) {
-        const upMove = highs[i] - highs[i - 1];
-        const downMove = lows[i - 1] - lows[i];
-        plusDM.push(upMove > downMove && upMove > 0 ? upMove : 0);
-        minusDM.push(downMove > upMove && downMove > 0 ? downMove : 0);
-        tr.push(Math.max(highs[i] - lows[i], Math.abs(highs[i] - closes[i - 1]), Math.abs(lows[i] - closes[i - 1])));
-    }
-    // Smooth with Wilder's smoothing (equivalent to EMA with alpha=1/period)
-    const smoothPlusDM = wilderSmooth(plusDM, period);
-    const smoothMinusDM = wilderSmooth(minusDM, period);
-    const smoothTR = wilderSmooth(tr, period);
-    // +DI and -DI series
-    const plusDISeries = [];
-    const minusDISeries = [];
-    for (let i = 0; i < smoothTR.length; i++) {
-        plusDISeries.push(smoothTR[i] > 0 ? (smoothPlusDM[i] / smoothTR[i]) * 100 : 0);
-        minusDISeries.push(smoothTR[i] > 0 ? (smoothMinusDM[i] / smoothTR[i]) * 100 : 0);
-    }
-    // DX series
-    const dxSeries = [];
-    for (let i = 0; i < plusDISeries.length; i++) {
-        const sum = plusDISeries[i] + minusDISeries[i];
-        dxSeries.push(sum > 0 ? (Math.abs(plusDISeries[i] - minusDISeries[i]) / sum) * 100 : 0);
-    }
-    // ADX = Wilder smooth of DX
-    const adxSeries = wilderSmooth(dxSeries, period);
-    return {
-        adx: Math.round(adxSeries[adxSeries.length - 1] ?? 0),
-        plusDI: Math.round(plusDISeries[plusDISeries.length - 1] ?? 0),
-        minusDI: Math.round(minusDISeries[minusDISeries.length - 1] ?? 0),
-    };
-}
-// ─── Ichimoku Cloud ─────────────────────────────────────────────────────
-export function computeIchimoku(highs, lows, closes, tenkanPeriod = 9, kijunPeriod = 26, senkouBPeriod = 52) {
-    const n = highs.length;
-    if (n < senkouBPeriod) {
-        const p = closes[n - 1] ?? 0;
-        return { tenkan: p, kijun: p, senkouA: p, senkouB: p, chikou: p, cloudPosition: 'inside' };
-    }
-    const midpoint = (arr, period, end) => {
-        const slice = arr.slice(Math.max(0, end - period + 1), end + 1);
-        return (Math.max(...slice) + Math.min(...slice)) / 2;
-    };
-    const tenkan = midpoint(highs.concat().map((h, i) => Math.max(h, lows[i])), tenkanPeriod, n - 1);
-    const kijun = midpoint(highs.concat().map((h, i) => Math.max(h, lows[i])), kijunPeriod, n - 1);
-    // Recalculate properly using highs and lows separately
-    const tenkanH = Math.max(...highs.slice(-tenkanPeriod));
-    const tenkanL = Math.min(...lows.slice(-tenkanPeriod));
-    const tenkanVal = (tenkanH + tenkanL) / 2;
-    const kijunH = Math.max(...highs.slice(-kijunPeriod));
-    const kijunL = Math.min(...lows.slice(-kijunPeriod));
-    const kijunVal = (kijunH + kijunL) / 2;
-    const senkouA = (tenkanVal + kijunVal) / 2;
-    const senkouBH = Math.max(...highs.slice(-senkouBPeriod));
-    const senkouBL = Math.min(...lows.slice(-senkouBPeriod));
-    const senkouB = (senkouBH + senkouBL) / 2;
-    const chikou = closes[n - 1]; // Current close (projected back 26 periods)
-    const price = closes[n - 1];
-    const cloudTop = Math.max(senkouA, senkouB);
-    const cloudBottom = Math.min(senkouA, senkouB);
-    const cloudPosition = price > cloudTop ? 'above' : price < cloudBottom ? 'below' : 'inside';
-    return { tenkan: tenkanVal, kijun: kijunVal, senkouA, senkouB, chikou, cloudPosition };
-}
-// ─── OBV (On-Balance Volume) ────────────────────────────────────────────
-export function computeOBV(closes, volumes) {
-    if (closes.length < 2)
-        return { obv: 0, slope: 'flat' };
-    let obv = 0;
-    const obvSeries = [0];
-    for (let i = 1; i < closes.length; i++) {
-        if (closes[i] > closes[i - 1])
-            obv += volumes[i];
-        else if (closes[i] < closes[i - 1])
-            obv -= volumes[i];
-        obvSeries.push(obv);
-    }
-    // Slope over last 10 bars
-    const lookback = Math.min(10, obvSeries.length);
-    const recent = obvSeries.slice(-lookback);
-    const first = recent[0];
-    const last = recent[recent.length - 1];
-    const threshold = Math.abs(first) * 0.01; // 1% threshold
-    const slope = last - first > threshold ? 'rising' : last - first < -threshold ? 'falling' : 'flat';
-    return { obv, slope };
-}
-// ─── Supertrend (10, 3) ─────────────────────────────────────────────────
-export function computeSupertrend(highs, lows, closes, period = 10, multiplier = 3) {
-    const atrSeries = computeATRSeries(highs, lows, closes, period);
-    if (atrSeries.length === 0) {
-        return { value: closes[closes.length - 1] ?? 0, direction: 'bullish' };
-    }
-    // ATR series starts at index 1 (needs previous close for TR)
-    // Align: atrSeries[i] corresponds to bar index i+1
-    let upperBand = 0;
-    let lowerBand = 0;
-    let supertrend = 0;
-    let direction = 'bullish';
-    for (let i = 0; i < atrSeries.length; i++) {
-        const barIdx = i + 1; // offset for TR calculation
-        const hl2 = (highs[barIdx] + lows[barIdx]) / 2;
-        const atr = atrSeries[i];
-        const basicUpper = hl2 + multiplier * atr;
-        const basicLower = hl2 - multiplier * atr;
-        upperBand = i > 0 && basicUpper < upperBand && closes[barIdx - 1] > upperBand ? upperBand : basicUpper;
-        lowerBand = i > 0 && basicLower > lowerBand && closes[barIdx - 1] < lowerBand ? lowerBand : basicLower;
-        if (i === 0) {
-            supertrend = closes[barIdx] > upperBand ? lowerBand : upperBand;
-            direction = closes[barIdx] > upperBand ? 'bullish' : 'bearish';
-        }
-        else {
-            if (direction === 'bullish') {
-                if (closes[barIdx] < lowerBand) {
-                    direction = 'bearish';
-                    supertrend = upperBand;
-                }
-                else {
-                    supertrend = lowerBand;
-                }
-            }
-            else {
-                if (closes[barIdx] > upperBand) {
-                    direction = 'bullish';
-                    supertrend = lowerBand;
-                }
-                else {
-                    supertrend = upperBand;
-                }
-            }
-        }
-    }
-    return { value: supertrend, direction };
-}
-// ─── Williams %R (14) ───────────────────────────────────────────────────
-export function computeWilliamsR(highs, lows, closes, period = 14) {
-    if (highs.length < period)
-        return -50;
-    const recentHighs = highs.slice(-period);
-    const recentLows = lows.slice(-period);
-    const hh = Math.max(...recentHighs);
-    const ll = Math.min(...recentLows);
-    const close = closes[closes.length - 1];
-    return hh !== ll ? ((hh - close) / (hh - ll)) * -100 : -50;
-}
-// ─── Helper: EMA series ─────────────────────────────────────────────────
-function emaSeries(data, period) {
-    if (data.length === 0)
-        return [];
-    if (data.length < period)
-        return [data[data.length - 1]];
-    const k = 2 / (period + 1);
-    const result = [];
-    let ema = mean(data.slice(0, period));
-    result.push(ema);
-    for (let i = period; i < data.length; i++) {
-        ema = data[i] * k + ema * (1 - k);
-        result.push(ema);
-    }
-    return result;
-}
-// ─── Helper: SMA series ─────────────────────────────────────────────────
-function sma(data, period) {
-    if (data.length < period)
-        return data.length > 0 ? [mean(data)] : [];
-    const result = [];
-    for (let i = period - 1; i < data.length; i++) {
-        result.push(mean(data.slice(i - period + 1, i + 1)));
-    }
-    return result;
-}
-// ─── Helper: Wilder's smoothing ─────────────────────────────────────────
-function wilderSmooth(data, period) {
-    if (data.length < period)
-        return [];
-    const result = [];
-    result.push(mean(data.slice(0, period)));
-    for (let i = period; i < data.length; i++) {
-        result.push((result[result.length - 1] * (period - 1) + data[i]) / period);
-    }
-    return result;
-}

package/assets/shared/signals/indicators.d.ts

@@ -1,15 +0,0 @@
-export declare function computeEMA(data: number[], period: number): number;
-export declare function computeATR(highs: number[], lows: number[], closes: number[], period: number): number;
-export declare function computeATRSeries(highs: number[], lows: number[], closes: number[], period: number): number[];
-export declare function computeRSI(closes: number[], period: number): number;
-export declare function linearSlope(y: number[], x?: number[]): number;
-export declare function computeStd(data: number[]): number;
-export declare function mean(data: number[]): number;
-/** Find swing highs and lows from OHLCV bars (simple pivot-point method). */
-export declare function findSwingPoints(bars: {
-    high: number;
-    low: number;
-}[], lookback?: number): {
-    highs: number[];
-    lows: number[];
-};

package/assets/shared/signals/indicators.js

@@ -1,107 +0,0 @@
-// Shared indicator computation helpers.
-// Used by both regime feature engineering and signal condition evaluation.
-export function computeEMA(data, period) {
-    if (data.length < period)
-        return data[data.length - 1] ?? 0;
-    const k = 2 / (period + 1);
-    let ema = mean(data.slice(0, period));
-    for (let i = period; i < data.length; i++) {
-        ema = data[i] * k + ema * (1 - k);
-    }
-    return ema;
-}
-export function computeATR(highs, lows, closes, period) {
-    const series = computeATRSeries(highs, lows, closes, period);
-    return series[series.length - 1] ?? 0;
-}
-export function computeATRSeries(highs, lows, closes, period) {
-    if (highs.length < 2)
-        return [];
-    const tr = [];
-    for (let i = 1; i < highs.length; i++) {
-        tr.push(Math.max(highs[i] - lows[i], Math.abs(highs[i] - closes[i - 1]), Math.abs(lows[i] - closes[i - 1])));
-    }
-    const atr = [];
-    atr[0] = mean(tr.slice(0, period));
-    for (let i = 1; i < tr.length; i++) {
-        atr[i] = (atr[i - 1] * (period - 1) + tr[i]) / period;
-    }
-    return atr;
-}
-export function computeRSI(closes, period) {
-    if (closes.length < period + 1)
-        return 50;
-    const changes = [];
-    for (let i = 1; i < closes.length; i++) {
-        changes.push(closes[i] - closes[i - 1]);
-    }
-    let avgGain = 0;
-    let avgLoss = 0;
-    for (let i = 0; i < period; i++) {
-        if (changes[i] > 0)
-            avgGain += changes[i];
-        else
-            avgLoss -= changes[i];
-    }
-    avgGain /= period;
-    avgLoss /= period;
-    for (let i = period; i < changes.length; i++) {
-        const gain = changes[i] > 0 ? changes[i] : 0;
-        const loss = changes[i] < 0 ? -changes[i] : 0;
-        avgGain = (avgGain * (period - 1) + gain) / period;
-        avgLoss = (avgLoss * (period - 1) + loss) / period;
-    }
-    if (avgLoss === 0)
-        return 100;
-    const rs = avgGain / avgLoss;
-    return 100 - 100 / (1 + rs);
-}
-export function linearSlope(y, x) {
-    const n = y.length;
-    if (n < 2)
-        return 0;
-    const xs = x ?? Array.from({ length: n }, (_, i) => i);
-    const mx = mean(xs);
-    const my = mean(y);
-    let num = 0;
-    let den = 0;
-    for (let i = 0; i < n; i++) {
-        num += (xs[i] - mx) * (y[i] - my);
-        den += (xs[i] - mx) ** 2;
-    }
-    return den > 0 ? num / den : 0;
-}
-export function computeStd(data) {
-    if (data.length < 2)
-        return 0;
-    const avg = mean(data);
-    const variance = data.reduce((s, v) => s + (v - avg) ** 2, 0) / (data.length - 1);
-    return Math.sqrt(variance);
-}
-export function mean(data) {
-    if (data.length === 0)
-        return 0;
-    return data.reduce((s, v) => s + v, 0) / data.length;
-}
-/** Find swing highs and lows from OHLCV bars (simple pivot-point method). */
-export function findSwingPoints(bars, lookback = 5) {
-    const highs = [];
-    const lows = [];
-    for (let i = lookback; i < bars.length - lookback; i++) {
-        let isHigh = true;
-        let isLow = true;
-        for (let j = i - lookback; j <= i + lookback; j++) {
-            if (j === i)
-                continue;
-            if (bars[j].high >= bars[i].high)
-                isHigh = false;
-            if (bars[j].low <= bars[i].low)
-                isLow = false;
-        }
-        if (isHigh)
-            highs.push(bars[i].high);
-        if (isLow)
-            lows.push(bars[i].low);
-    }
-    return { highs, lows };
-}

package/dist/daemon.js

@@ -1,104 +0,0 @@
-// Keep the bridge running across reboots. Linux/systemd-user is implemented
-// fully; macOS and Windows fall back to printing the manual run command (a
-// launchd/Task-Scheduler unit is a follow-up). The bridge reads its config from
-// ~/.openclaw/openclaw.json, so until the user pastes their connect message the
-// service will start, find no token, and restart — harmless; it connects within
-// seconds of the agent writing the config.
-import { writeFileSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir, userInfo } from 'node:os';
-import { BRIDGE_DIR } from './paths.js';
-import { run, which } from './exec.js';
-import { step, ok, info, warn } from './ui.js';
-const SERVICE_NAME = 'reefclaw-bridge';
-const NODE = process.execPath; // absolute path to the node running the installer
-/**
- * Build the systemd user-unit text. Pure + exported so the path-quoting is
- * unit-testable. Both `node` (process.execPath) and `bridgeDir` (under the
- * user's home) can contain spaces. Quoting rules differ per directive:
- *  - ExecStart= is parsed with shell-like word splitting, so an unquoted
- *    `ExecStart=/home/a b/node …` reads the binary as `/home/a` — QUOTE both
- *    the binary and the script path.
- *  - WorkingDirectory= takes the raw value after `=` as a single path (no word
- *    splitting) — spaces are safe UNQUOTED, and quotes are treated as literal
- *    characters, failing the unit with "path is not absolute" (verified live
- *    on systemd 255 / Ubuntu 24.04). Do NOT quote it.
- */
-export function buildSystemdUnit(node, bridgeDir) {
-    const indexJs = join(bridgeDir, 'index.js');
-    return `[Unit]
-Description=ReefClaw connector - bridges OpenClaw to the ReefClaw dashboard
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-WorkingDirectory=${bridgeDir}
-ExecStart="${node}" "${indexJs}" --provider gateway --log-level info
-Restart=always
-RestartSec=5s
-
-[Install]
-WantedBy=default.target
-`;
-}
-function manualHint() {
-    warn('Could not set up an auto-start service on this OS yet.');
-    info('Keep the connector running with this command (leave it open / use your own service manager):');
-    info(`  "${NODE}" "${join(BRIDGE_DIR, 'index.js')}" --provider gateway`);
-}
-function installSystemd() {
-    if (!which('systemctl'))
-        return false;
-    const unitDir = join(homedir(), '.config', 'systemd', 'user');
-    mkdirSync(unitDir, { recursive: true });
-    const unit = buildSystemdUnit(NODE, BRIDGE_DIR);
-    writeFileSync(join(unitDir, `${SERVICE_NAME}.service`), unit, 'utf-8');
-    run('systemctl', ['--user', 'daemon-reload']);
-    const enabled = run('systemctl', ['--user', 'enable', '--now', `${SERVICE_NAME}.service`]);
-    if (!enabled.ok) {
-        warn('systemd --user enable/start did not succeed:');
-        if (enabled.stderr.trim())
-            info(enabled.stderr.trim().split('\n').slice(-2).join('\n'));
-        info(`Try:  systemctl --user enable --now ${SERVICE_NAME}.service`);
-        return false;
-    }
-    // `enable --now` can exit 0 while the unit failed to load (e.g. a bad unit
-    // file setting) — verify the unit actually came up before claiming ✓.
-    // 'active' = running; 'activating' = the expected pre-token restart loop
-    // (the bridge exits until the user pastes their connect message, and
-    // Restart=always re-launches it). Anything else (inactive/failed) means the
-    // unit never loaded.
-    const active = run('systemctl', ['--user', 'is-active', `${SERVICE_NAME}.service`]);
-    const state = active.stdout.trim();
-    if (state !== 'active' && state !== 'activating') {
-        warn(`the service did not come up (state: ${state || 'unknown'}).`);
-        info(`Inspect:  systemctl --user status ${SERVICE_NAME}.service`);
-        return false;
-    }
-    // Linger lets the user service run without an active login session (servers).
-    // Best-effort: needs privileges; non-fatal if it fails.
-    const linger = run('loginctl', ['enable-linger', userInfo().username]);
-    if (linger.ok) {
-        info('enabled linger (service survives logout / reboot)');
-    }
-    else {
-        info('note: run `sudo loginctl enable-linger $USER` so the connector survives logout.');
-    }
-    return true;
-}
-export function installDaemon() {
-    step('Starting the connector as a background service');
-    if (process.platform === 'linux') {
-        if (installSystemd()) {
-            ok(`connector running as a systemd user service (${SERVICE_NAME})`);
-            info(`logs:  journalctl --user -u ${SERVICE_NAME} -f`);
-            return true;
-        }
-        manualHint();
-        return false;
-    }
-    // macOS / Windows: manual for now (launchd / Task Scheduler unit is a follow-up).
-    manualHint();
-    return false;
-}