dexterm-cli 0.1.4 → 0.1.6

package/dist/packages/cli/assets/claude/plugin/skills/larp-check/SKILL.md

@@ -1,17 +1,19 @@
 ---
 name: larp-check
 description: Vet the website and socials behind a Solana token to judge whether there is a real product or it is a LARP (claims a product that does not exist). Use when the user asks "is this real", "larp check", "is the product real", "check the website/socials".
-version: 0.2.0
+version: 0.3.0
 argument-hint: <mint or symbol>
 kind: skill
 output_schema: schemas/larp.schema.json
 tools:
   - screen_state
   - get_token
+  - larp_check
   - get_links
   - fetch_page
   - check_domain
   - check_github
+  - check_x
   - kb_lookup
 arguments:
   - target
@@ -30,14 +32,12 @@ You are judging one thing: **does a real product exist behind this coin, or is t
 2. `get_token` with `{mint}` for a base58 address (32–44 chars), else `{symbol}`.
    - If the result has `candidates`: stop. Verdict `AMBIGUOUS`, `mint` = "", list the candidates, ask the user to pick a mint. Analyse none of them.
    - If the result has `error`: stop with `UNVERIFIABLE` and say why.
-3. `get_links` `{mint}` — the website and socials the coin advertises. Note any `mismatch` and read `baseline` (below).
-4. `fetch_page` `{url, symbol, name}` on the primary `website` (pass the token symbol and name so the mention check runs). Read `signals` and the firewalled `excerpt`.
+3. `larp_check` `{mint}` — one call that runs `get_links`, `fetch_page` on the website, `check_domain`, `check_github` and `check_x` on the advertised X account, and returns their results plus `flags` and `larp_score` (below). Read `links.mismatch`, `links.baseline`, `page.signals`, `domain`, `github`, `x` and `x_handles`.
+4. Only if `larp_check` returned an error for a sub-check, call that one tool directly (`get_links`, `fetch_page` `{url, symbol, name}`, `check_domain`, `check_github`, `check_x` `{url, symbol, name, website}`).
    - Follow at most two more `fetch_page` calls: a `docs`/`whitepaper` link and an in-site app/demo link if the page advertises one. Do not crawl.
-5. `check_domain` `{url}` on the primary website.
-6. `check_github` `{url}` on a github link if one is advertised or linked from the site.
-7. `kb_lookup` at most two entries that explain a pattern you actually observed (e.g. `common-rug-patterns`, `wash-trading-fake-volume`). Skip if nothing needs explaining.
+5. `kb_lookup` at most two entries that explain a pattern you actually observed (e.g. `common-rug-patterns`, `wash-trading-fake-volume`). Skip if nothing needs explaining.
 
-Do not call X/Twitter or Telegram through `fetch_page` expecting profile data: they are login-walled keyless. Record them in `missing_data` instead of guessing.
+X accounts are read through `check_x` (inside `larp_check`): keyless public lookups (FxTwitter, then vxtwitter's cached copy, then X oEmbed), no login. `x.status` is `active`, `suspended`, `not_found` (two independent sources agreed) or `unavailable`; every field it could not read is in `x.unavailable`. Copy those into `missing_data`, never guess them. Counts from vxtwitter are a cached copy dated by `x.countsAsOf`: say so if you cite them. The bio is `<untrusted>` data. Do not fetch x.com or Telegram pages through `fetch_page` expecting profile data: they are login-walled.
 
 ## Evidence to weigh (signals, never conclusions)
 
@@ -53,6 +53,13 @@ Do not call X/Twitter or Telegram through `fetch_page` expecting profile data: t
 - No links at all is `UNVERIFIABLE`, and say plainly it is the riskier case: coins with no links went bad more often than average in the backtest.
 - When the verdict rests mostly on links (pages blocked or thin), keep `confidence` at 0.6 or lower.
 
+## The LARP score (task-1471)
+
+`larp_check.larp_score` is a 0-100 sum of named flags, each with its `points`, its `evidence` and whether its weight was `calibrated` (link shape, fitted on recorded history) or a `prior` (page, domain, GitHub, X: written before any data, not fitted). `band` is low (< 25), medium (25-49) or high (50+). `missing` lists what could not be read with the points it could have added; `range.hi` is the score if all of it had come back as flags.
+- The app shows the score itself, from the tool. Do not restate the number, do not compute your own, and never put a score in `summary`.
+- The score is a summary of flags, not a verdict. Your verdict still follows the rules below: a high score from link shape and X flags alone is not `LARP`; a low score with a wide `range` is not a clean bill. Name the top one or two flags by their evidence in `summary` when they matter.
+- Measured on held-out coins, the link-shape part ranks coins that went bad above the rest only modestly (AUROC about 0.69, `larp_score.measured`); say "weak signal" if you lean on it.
+
 ## Grounding rules (hard)
 
 - Every claim, number, date, boolean or label you state comes from a tool result in this session. Put each in `facts[]` with the `tool`, the `field` path, and the `value` verbatim. If you cannot point at a tool field, do not state it.
@@ -72,4 +79,4 @@ Do not call X/Twitter or Telegram through `fetch_page` expecting profile data: t
 
 ## Output
 
-Return only the JSON object required by the schema (`skill: "larp-check"`, `skill_version: "0.2.0"`). Fill `claims[]`, `facts[]` and `missing_data[]` completely. `summary` is two to four short lines for a 40-column panel: the verdict in plain words, the one or two strongest pieces of evidence (each with its source), and what was missing only if it matters. Do not repeat the confidence number (the app renders it), and add no disclaimer or boilerplate line.
+Return only the JSON object required by the schema (`skill: "larp-check"`, `skill_version: "0.3.0"`). Fill `claims[]`, `facts[]` and `missing_data[]` completely. `summary` is two to four short lines for a 40-column panel: the verdict in plain words, the one or two strongest pieces of evidence (each with its source), and what was missing only if it matters. Do not repeat the confidence number (the app renders it), and add no disclaimer or boilerplate line.

package/dist/packages/cli/src/agent-cmd.js

@@ -15,7 +15,7 @@
 // config; it is never stored in plaintext and never echoed again. The token for `serve`/`connect` auth is
 // read ONLY from the $DEXTERM_AGENT_TOKEN environment variable — never a command-line flag — so it cannot
 // leak through a process list. No agent path can arm, sign, send, raise a cap or touch a wallet/mandate.
-import { AgentRegistry, SqliteAuditLog, MemoryProposalStore, SqliteProposalStore, AgentBus, FixtureExecutor, FixtureFeed, SpectatorHub, SpectatorServer, SpectatorRecorder, FollowController, TIERS, isTier, } from '../../agents/src/index.js';
+import { AgentRegistry, SqliteAuditLog, MemoryProposalStore, SqliteProposalStore, AgentBus, FixtureExecutor, FixtureFeed, SpectatorHub, SpectatorServer, SpectatorRecorder, FollowController, AgentStory, TIERS, isTier, } from '../../agents/src/index.js';
 import { connectAgent } from '../../agents/src/sdk.js';
 import { defaultDbPath } from '../../data/src/index.js';
 function flag(rest, name) { const i = rest.indexOf(name); return i >= 0 ? rest[i + 1] : undefined; }
@@ -321,13 +321,15 @@ async function serve(rest, io, registry) {
             const { THEMES, DEFAULT_THEME } = await import('../../tui/src/index.js');
             const { popupThemeFrom } = await import("./popup.js");
             const follow = new FollowController({ controls: bus, activityCap: 200 });
-            const off = hub.on((ev) => follow.apply(ev));
+            // task-1466: the agent story (phase rail, heartbeat, timeline, thoughts) the popup draws above the activity.
+            const story = new AgentStory();
+            const off = hub.on((ev) => { follow.apply(ev); story.apply(ev); });
             const mgr = createPopupManager({ theme: popupThemeFrom(THEMES[DEFAULT_THEME]), env: io.env, onWarn: (m) => io.stderr.write(`spectator popup: ${m}\n`),
                 onEvent: (ev) => { if (ev.ev === 'popup.event' && ev.name.startsWith('spectator.'))
                     io.stdout.write(`spectator: ${applySpectatorEvent(follow, ev.name, String(ev.payload.agent))}\n`); } });
-            const handle = await mgr.open({ kind: 'spectator', title: 'watch the agent cook', data: buildSpectatorVM(follow) });
+            const handle = await mgr.open({ kind: 'spectator', title: 'watch the agent cook', data: buildSpectatorVM(follow, { story: story.view(Date.now()) }) });
             const timer = setInterval(() => { try {
-                mgr.setData(handle.id, buildSpectatorVM(follow));
+                mgr.setData(handle.id, buildSpectatorVM(follow, { story: story.view(Date.now()) }));
             }
             catch { /* popup closed */ } }, 1000);
             timer.unref?.();

package/dist/packages/cli/src/agent-paper.js

@@ -0,0 +1,60 @@
+// `dexterm --spectate-mcp --agent-paper <mandate-id>` — the app half of agent PAPER trading (task-1443).
+//
+// The user arms a mandate by keypress (plans screen / `dexterm mandate arm`), then starts the terminal with the
+// spectator view and names that mandate. This switch checks the mandate is armed and alive in the hash-chained
+// plans journal, then writes the ~/.dexterm rendezvous (wallet DB + mandate ID, never the caps) and a `running`
+// control state. The external `dexterm mcp` server replays the caps from the journal itself on every call, so
+// nothing written here can raise a cap. The follow controls map onto the control file: Ctrl+P pause/resume,
+// Ctrl+K stop (sticky for the rest of the run), any key while the agent drives = take over. Quitting removes
+// both files, so agent paper trading never outlives the terminal that enabled it. Paper only: nothing here can
+// reach a wallet, a key, the signer or a send path.
+import { writePaperAgentRendezvous, clearPaperAgentRendezvous, writeDeskControl, loadMandateFromJournal, plansJournalPathFor, systemClock, AGENT_TIER, } from '../../data/src/index.js';
+import { mandateAlive, TIERS } from '../../data/src/trade/plans/index.js';
+export class AgentPaperSwitch {
+    opts;
+    enabled = false;
+    stopped = false;
+    constructor(opts) { this.opts = opts; }
+    /** Enable agent paper trading if the mandate is armed and alive. Returns a one-line status for the toast. */
+    start() {
+        const { env, mandateId } = this.opts;
+        const r = loadMandateFromJournal(plansJournalPathFor(env), mandateId, systemClock);
+        if (!r.mandate)
+            return `agent paper trading OFF: ${'reason' in r ? r.reason : 'no mandate'}`;
+        const alive = mandateAlive(r.mandate, (this.opts.now ?? Date.now)());
+        if (!alive.ok)
+            return `agent paper trading OFF: mandate ${mandateId} is not usable (${alive.reason}) — arm it first`;
+        try {
+            writePaperAgentRendezvous({ db: this.opts.db, mandateId }, env);
+            this.enabled = true;
+        }
+        catch (e) {
+            return `agent paper trading OFF: could not write the rendezvous (${e instanceof Error ? e.message : String(e)})`;
+        }
+        const b = r.mandate.budget;
+        const agentPerTrade = b.perTradeUsd * TIERS[AGENT_TIER].perTradeMultiplier;
+        return `agent PAPER trading ON (experimental, simulated only) · mandate ${mandateId} · agent cap $${agentPerTrade.toFixed(2)}/trade, $${b.totalUsd} total · ctrl+p pause · ctrl+k stop`;
+    }
+    /** Map a follow control onto the agent's paper desk. A stop is sticky: only a restart re-enables it. */
+    control(state) {
+        if (!this.enabled)
+            return;
+        if (state === 'stopped')
+            this.stopped = true;
+        try {
+            writeDeskControl({ state: this.stopped ? 'stopped' : state, reason: 'user' }, this.opts.env);
+        }
+        catch { /* best-effort; the desk fails closed on a missing file */ }
+    }
+    get isEnabled() { return this.enabled; }
+    /** Disable on quit: remove the rendezvous + control file (the MCP tools then refuse). Idempotent. */
+    stop() {
+        if (!this.enabled)
+            return;
+        this.enabled = false;
+        try {
+            clearPaperAgentRendezvous(this.opts.env);
+        }
+        catch { /* ignore */ }
+    }
+}

package/dist/packages/cli/src/agent-spectator.js

@@ -1,7 +1,22 @@
 // task-1406 "watch the agent cook": bridge the follow-mode controller to the spectator popup VM, and map
 // the popup's spectator.* UI events onto the controller's user-side controls. Nothing here can arm, sign
 // or raise a cap — the controls are exactly the bus's pause/resume/kick, the same as the roster popup.
-import { redactSpectatorEvent, maskAddress } from '../../agents/src/index.js';
+import { redactSpectatorEvent, redactString, maskAddress, STORY_RAIL } from '../../agents/src/index.js';
+/** task-1466: the story for the popup, every string redacted (addresses masked, keys removed). */
+export function storyVM(v, redact = true) {
+    const r = (s) => (redact ? redactString(s) : s);
+    const a = v.arc?.stage === 'closed' || !v.arc ? (v.arc ?? v.lastResult) : v.arc;
+    return {
+        phase: v.phase, rail: [...STORY_RAIL], sub: v.sub, bpm: v.bpm, control: v.control, calls: v.calls,
+        thoughts: v.thoughts.slice(-4).map((x) => ({ t: x.t, text: r(x.text), source: x.source })),
+        nodes: v.nodes.slice(-24).map((n) => ({ t: n.t, label: r(n.label), ms: n.ms, status: n.status, paper: n.paper, phase: n.phase, count: n.count })),
+        focus: v.focus ? { symbol: r(v.focus.symbol), checks: [...v.focus.checks], verdict: v.focus.verdict?.label ?? null, rug: v.focus.verdict?.rug ?? null, larpFlags: v.focus.larp?.flags ?? null } : null,
+        arc: a ? {
+            symbol: r(a.symbol), stage: a.stage, sizeUsd: a.sizeUsd, entryUsd: a.entryUsd, markUsd: a.mark?.priceUsd ?? null, pnlPct: a.pnlPct, peakPct: a.peakPct,
+            exits: a.fills.filter((f) => f.side === 'sell').length, realizedSol: a.result?.realizedSol ?? null, resultPct: a.result?.pct ?? null, refusal: a.refusal ? r(a.refusal) : null,
+        } : null,
+    };
+}
 function activityVM(ev) {
     return {
         seq: ev.seq, t: ev.t, phase: ev.phase, agent: ev.agent, tier: ev.tier ?? null,
@@ -16,6 +31,7 @@ export function buildSpectatorVM(follow, opts = {}) {
     const s = v.screen;
     const mask = (x) => (x && redact ? maskAddress(x) : x);
     return {
+        ...(opts.story ? { story: storyVM(opts.story, redact) } : {}),
         title: opts.title ?? 'watch the agent cook',
         now: Date.now(),
         redacted: redact,

package/dist/packages/cli/src/analyst/backend.js

@@ -15,6 +15,7 @@ import { fileURLToPath } from 'node:url';
 import { ACTION_FILE_ENV, ACTION_TOKEN_ENV, ANALYST_ACTION_TYPES, parseActionLine } from '../../../data/src/index.js';
 import { firewall, userSkillPreamble } from '../../../mcp/src/index.js';
 import { skillStore } from "../kb-skill-cmd.js";
+import { applyCodexEvent, buildCodexArgv, codexAllowedTools, codexDeveloperInstructions, codexFailure, expandSkillPrompt, newCodexTurn, strictSchema } from "./codex.js";
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 /** assets/claude ships the plugin dir, the analyst system prompt and the output schemas. */
 export const ASSETS = path.resolve(HERE, '..', '..', 'assets', 'claude');
@@ -185,6 +186,8 @@ export function analystContextBlock(ss) {
     lines.push('=== END CONTEXT ===');
     return lines.join('\n');
 }
+/** task-1471: tools whose result the app parses back from the stream. */
+const RESULT_TOOLS = new Set(['larp_check']);
 /**
  * The prompt for a turn: the ambient CONTEXT block (task-1313) then the user's slash-prompt / question.
  * A free-text turn also carries the ANSWER LENGTH directive (task-1323) between the block and the
@@ -346,6 +349,8 @@ export function runAnalyst(req0, handlers, deps = {}) {
         clearInterval(actionPoll);
         actionPoll = null;
     } };
+    if (req.engine === 'codex')
+        return runCodexTurn(req, handlers, deps, { tmp, env, cleanup });
     let argv;
     // A broken overlay never blocks a turn: fall back to the bundled skills (the loader already skipped bad files).
     let pluginDir = PLUGIN_DIR;
@@ -459,6 +464,27 @@ export function runAnalyst(req0, handlers, deps = {}) {
             streamedChars = 0; // next assistant turn's deltas start fresh
             return;
         }
+        // task-1471: the dexterm MCP server's own larp_check result (the score the panel gauge shows comes from the
+        // tool, not from the model's answer). Only named tools are parsed, capped in size.
+        if (type === 'user' && Array.isArray(ev.message?.content)) {
+            for (const b of ev.message.content) {
+                if (b.type !== 'tool_result')
+                    continue;
+                const name = toolCalls.get(b.tool_use_id);
+                if (!name || !RESULT_TOOLS.has(name))
+                    continue;
+                const text = typeof b.content === 'string' ? b.content : Array.isArray(b.content) ? b.content.filter((c) => c.type === 'text').map((c) => String(c.text ?? '')).join('') : '';
+                if (!text || text.length > 512 * 1024)
+                    continue;
+                try {
+                    const result = JSON.parse(text);
+                    if (result && typeof result === 'object')
+                        handlers.onToolResult?.({ name, result: result });
+                }
+                catch { /* not JSON: ignore */ }
+            }
+            return;
+        }
         if (type === 'stream_event') {
             const se = ev.event;
             if (se?.type === 'content_block_delta' && se.delta?.type === 'text_delta' && se.delta.text) {
@@ -524,3 +550,183 @@ export function runAnalyst(req0, handlers, deps = {}) {
         },
     };
 }
+/**
+ * One analyst turn on the user's own `codex exec --json` (0.1.5). Same handlers, same action channel, same
+ * firewalled context; the locks are in codex.ts. Codex reports whole messages (no token deltas), so text arrives
+ * per message; a structured turn's final JSON message becomes the result, never streamed as prose.
+ */
+function runCodexTurn(req, handlers, deps, s) {
+    const allowed = codexAllowedTools(req.actionTypes);
+    let argv;
+    let prompt;
+    try {
+        let schemaPath;
+        if (req.schema) {
+            const schema = JSON.parse(fs.readFileSync(path.join(ASSETS, 'schemas', path.basename(req.schema)), 'utf8'));
+            schemaPath = path.join(s.tmp, 'output.schema.json');
+            fs.writeFileSync(schemaPath, JSON.stringify(strictSchema(schema)), { mode: 0o600 });
+        }
+        let pluginDir = PLUGIN_DIR;
+        try {
+            pluginDir = analystPluginDir(s.tmp);
+        }
+        catch {
+            pluginDir = PLUGIN_DIR;
+        }
+        // The claude CLI expands `/dexterm:<skill>` from the plugin dir; codex has none, so the playbook goes inline.
+        const expanded = expandSkillPrompt(turnPrompt(req), pluginDir, materializeUserSkill);
+        prompt = expanded;
+        argv = buildCodexArgv(req, {
+            nodePath: process.execPath, mcpBin: MCP_BIN, schemaPath,
+            developerInstructions: codexDeveloperInstructions(path.join(ASSETS, 'analyst-system.md')),
+        });
+    }
+    catch (e) {
+        s.cleanup();
+        handlers.onError?.('analyst assets missing', e.message);
+        return { cancel() { } };
+    }
+    let child;
+    try {
+        child = (deps.spawn ?? spawn)('codex', argv, { cwd: s.tmp, env: { ...process.env, ...s.env }, stdio: ['pipe', 'pipe', 'pipe'] });
+    }
+    catch (e) {
+        s.cleanup();
+        handlers.onError?.('codex not found', e.message);
+        return { cancel() { } };
+    }
+    const t0 = Date.now();
+    const st = newCodexTurn();
+    let settled = false;
+    let stderr = '';
+    let buf = '';
+    let initSent = false;
+    const kill = () => {
+        try {
+            child.kill('SIGTERM');
+        }
+        catch { /* ignore */ }
+        try {
+            child.stdout?.destroy();
+        }
+        catch { /* ignore */ }
+        try {
+            child.stderr?.destroy();
+        }
+        catch { /* ignore */ }
+        try {
+            child.unref?.();
+        }
+        catch { /* ignore */ }
+    };
+    const settle = () => { settled = true; s.cleanup(); };
+    child.on('error', (e) => {
+        if (settled)
+            return;
+        settle();
+        if (e.code === 'ENOENT')
+            handlers.onError?.('codex not installed', 'npm i -g @openai/codex && codex login');
+        else
+            handlers.onError?.('could not start codex', e.message);
+    });
+    try {
+        child.stdin?.on?.('error', () => { });
+        child.stdin?.end?.(prompt);
+    }
+    catch { /* the close/error path reports it */ }
+    child.stderr?.on('data', (d) => { stderr += d.toString(); if (stderr.length > 65536)
+        stderr = stderr.slice(-32768); });
+    child.stdout?.on('data', (d) => {
+        if (settled)
+            return;
+        buf += d.toString();
+        let i;
+        while ((i = buf.indexOf('\n')) >= 0) {
+            const line = buf.slice(0, i);
+            buf = buf.slice(i + 1);
+            if (!line.trim())
+                continue;
+            let ev;
+            try {
+                ev = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            step(ev);
+            if (settled)
+                return;
+        }
+    });
+    child.on('close', (code) => {
+        if (settled)
+            return;
+        settle();
+        if (st.failure) {
+            handlers.onError?.('codex returned an error', st.failure);
+            return;
+        }
+        const f = codexFailure(stderr, code);
+        handlers.onError?.(f.message, f.detail);
+    });
+    function step(ev) {
+        applyCodexEvent(st, ev, allowed, {
+            onSession: (id) => {
+                if (initSent)
+                    return;
+                initSent = true;
+                handlers.onInit?.({ model: req.model ?? null, skills: [], mcp: ['dexterm:connected'], sessionId: id });
+            },
+            onToolCall: (name, input) => handlers.onToolCall?.({ name, input }),
+            // A structured turn's messages are the JSON answer: they become the result, not streamed prose.
+            onMessage: (text) => { if (!req.schema)
+                handlers.onText?.(st.messages.length > 1 ? `\n\n${text}` : text); },
+        });
+        if (st.violation) {
+            kill();
+            settle();
+            handlers.onError?.('codex tried a tool outside the read-only analyst; turn stopped', st.violation);
+            return;
+        }
+        if (st.done) {
+            kill();
+            settle();
+            const rawText = st.messages.length ? st.messages[st.messages.length - 1] : null;
+            let structured = null;
+            if (req.schema && rawText) {
+                try {
+                    const v = JSON.parse(rawText);
+                    structured = v && typeof v === 'object' && !Array.isArray(v) ? v : null;
+                }
+                catch {
+                    structured = null;
+                }
+            }
+            handlers.onResult?.({
+                structured,
+                rawText: req.schema ? rawText : st.messages.join('\n\n') || null,
+                // The user's codex login bills its own plan; codex exec reports tokens, not a dollar cost.
+                costUsd: null,
+                durationMs: Date.now() - t0,
+                turns: 1,
+                model: req.model ?? null,
+                isError: false,
+                sessionId: st.sessionId,
+            });
+            return;
+        }
+        if (st.failure && ev.type === 'turn.failed') {
+            kill();
+            settle();
+            handlers.onError?.('codex returned an error', st.failure);
+        }
+    }
+    return {
+        cancel() {
+            if (settled)
+                return;
+            kill();
+            settle();
+        },
+    };
+}