PineNode

Labels the strategy in reports, the debugger header, and saved-strategy lists. Optional but recommended — the default is "Untitled Strategy".

pn.name('Mean Reversion v2');

The per-bar callback is the heart of the strategy. It receives a freshcontext argument on every bar containing the series, order helpers, math utilities, and the Sentimentor data namespace.

pn.onBar((ctx) => {
  // ctx.series, ctx.buy, ctx.sell, ctx.crossOver, ctx.crossUnder,
  // ctx.highest, ctx.lowest, ctx.sentimentor
});

Most strategies destructure the arguments inline for readability:

pn.onBar(({ series, buy, sell, crossOver, sentimentor }) => {
  /* ... */
});

Number of closed bars seen so far. Use it to guard against the warm-up problem: indicators with a period of N can't produce meaningful values untilseries.length >= N.

pn.onBar(({ series }) => {
  if (series.length < 50) return;        // warm-up
  // ... safe to read history here
});

For slices of consecutive history, indicators do this for you. If you genuinely need the raw array, use series.slice(n) which returns the last n closes (oldest-first):

const last10 = series.slice(10);
// last10 = [close-9, close-8, ..., close-0]

const sma = new SMA(20);
pn.onBar(({ series }) => {
  sma.next(series);
  console.log('SMA(20) =', sma.value);
});

Constructor: new SMA(period). Returns number | null (null during warm-up).

const ema = new EMA(50);
pn.onBar(({ series }) => {
  ema.next(series);
  if (series.close(0) > ema.value) buy('above EMA');
});

Constructor: new EMA(period).

Returns a 0–100 oscillator. Default period is 14, matching Pine's default.

const rsi = new RSI(14);
pn.onBar(({ series, buy, sell }) => {
  rsi.next(series);
  if (rsi.value < 30) buy('RSI oversold');
  if (rsi.value > 70) sell('RSI overbought');
});

Constructor: new RSI(period = 14).

const macd = new MACD(12, 26, 9);
pn.onBar(({ series }) => {
  macd.next(series);
  const { macd: macdLine, signal, histogram } = macd.value;
});

Constructor: new MACD(fast = 12, slow = 26, signal = 9).

Returns { macd, signal, histogram }.

const bb = new BollingerBands(20, 2);
pn.onBar(({ series, buy }) => {
  bb.next(series);
  if (series.close(0) < bb.value.lower) buy('lower band touch');
});

Constructor: new BollingerBands(period = 20, stdDevMultiplier = 2).

Returns { middle, upper, lower }.

Volatility — useful for stop placement and position sizing.

const atr = new ATR(14);
pn.onBar(({ series, buy }) => {
  atr.next(series);
  const stopDist = atr.value * 2;
  // ...
});

Constructor: new ATR(period = 14).

const stoch = new Stochastic(14, 3);
pn.onBar(({ series }) => {
  stoch.next(series);
  const { k, d } = stoch.value;
});

Constructor: new Stochastic(kPeriod = 14, dPeriod = 3).

Returns { k, d }.

const adx = new ADX(14);
pn.onBar(({ series }) => {
  adx.next(series);
  const { adx: trendStrength, plusDI, minusDI } = adx.value;
  if (trendStrength > 25 && plusDI > minusDI) buy('strong uptrend');
});

Constructor: new ADX(period = 14).

Returns { adx, plusDI, minusDI }.

const obv = new OBV();
pn.onBar(({ series }) => { obv.next(series); });

Constructor: new OBV(). No period.

const vwap = new VWAP();
pn.onBar(({ series, buy }) => {
  vwap.next(series);
  if (series.close(0) > vwap.value) buy('above VWAP');
});

Constructor: new VWAP(). Session reset is automatic.

Inverted oscillator — readings near -100 are oversold, near 0 are overbought.

const wr = new WilliamsR(14);
pn.onBar(({ series, buy }) => {
  wr.next(series);
  if (wr.value < -80) buy('Williams oversold');
});

Constructor: new WilliamsR(period = 14).

const roc = new ROC(12);
pn.onBar(({ series }) => { roc.next(series); });

Constructor: new ROC(period = 12).

const cci = new CCI(20);
pn.onBar(({ series, buy }) => {
  cci.next(series);
  if (cci.value < -100) buy('CCI oversold');
});

Constructor: new CCI(period = 20).

The deterministic importers can emit the additional constructors used by Pine's moving-average, dispersion, range and momentum helpers: WMA,RMA, VWMA, HMA, ALMA,SWMA, StandardDeviation, Variance,MeanDeviation, Highest, Lowest,RollingSum, CumulativeSum, Change,Momentum, LinearRegression, TrueRangeand MFI.

const cumulative = new CumulativeSum();
pn.onBar(({ series }) => {
  cumulative.update(series.close(0) - series.open(0));
  // cumulative.get(0) matches imported ta.cum(close - open)
});

Use .update(value) for an arbitrary scalar source and.next(series) for calculations that require the real OHLCV bar.

1. Open a symbol in the chart.
2. Select Create Custom Indicator in the chart header, or Custom Indicators from the right rail.
3. Start from the PineNode template, import a TradingView Pine Script indicator, or select Ask Augur and describe the study.
4. Select Run Custom Indicator to compile it against the current symbol and timeframe.
5. Review the plots and inputs, then select Add to chart.

Augur output is a starting point, not a hidden signal. Review its formula, parameter bounds, warm-up behavior and plot placement before adding or saving it.

On desktop, Custom Indicators opens as a wide resizable chart panel. Use the action rail to close it, open this documentation or switch between the normal and maximized layouts without leaving the active symbol.

Select Import from TV Pine Script at the top of Custom Indicators. The import panel uses the same workflow as Strategy Tester: paste Pine v2-v6 source, load an example, upload a .pine file, clear the editor or selectConvert. Line and character counts, warnings and unsupported-capability counts are shown before conversion.

Conversion runs locally and deterministically; it does not send the script to Augur. A successful conversion replaces the PineNode editor draft while keeping the source visible for review. Run the converted indicator before adding or saving it.

Call pn.indicator(name, options) once, then chain.onBar(callback). Set overlay: true for a price-chart overlay or overlay: false for a separate indicator pane.

pinenode
const fastLength = pn.param('Fast Length', 20, 2, 200, 1);
const showSlow = pn.boolParam('Show Slow', true);
const fast = new EMA(fastLength);
const slow = new EMA(50);

pn
  .indicator('EMA Research Overlay', { overlay: true })
  .onBar(({ series, plot }) => {
    fast.next(series);
    slow.next(series);

    plot('Fast EMA', fast.get(0), {
      color: '#22d3ee',
      lineWidth: 2,
    });
    if (showSlow) {
      plot('Slow EMA', slow.get(0), {
        color: '#f472b6',
        lineWidth: 2,
      });
    }
  });

The callback receives the same historical series accessors used by a strategy plus plot(). The runtime includes the imported rolling and smoothing libraries listed above as well as SMA, EMA, RSI, MACD, Bollinger Bands, ATR, Stochastic, ADX, OBV, VWAP, Williams %R, ROC, CCI and cumulative sum.

pn.param(name, default, min, max, step?) declares a bounded numeric input.pn.boolParam(name, default) declares a switch. After a successful run, the builder shows both kinds of inputs and reruns the indicator when a value changes.

const length = pn.param('Length', 14, 2, 100, 1);
const showSignal = pn.boolParam('Show signal line', true);

plot(name, value, options?) records one numeric value for the current bar. Reuse the same plot name on every bar. A non-finite value creates a gap during warm-up or when a condition intentionally hides the plot.

plot('Momentum', value, {
  color: '#a78bfa',
  lineWidth: 2,
  renderType: 'histogram', // 'line' | 'histogram' | 'area'
  pane: 'sub',             // omit for the main chart
  independentScale: true,
  scaleGroup: 'momentum',
});

The indicator-level overlay option supplies the default placement. A plot can override it with pane. Use independentScale or a shared scaleGroup when multiple plots should not inherit the price scale.

The chart's Indicators panel can also override placement for selected studies. With Overlay on main chart checked, plots share the price chart; uncheck it to give each active indicator—including a saved custom indicator—its own pane.

• Run Custom Indicator validates the source and previews the emitted plots against the current chart data.
• Add to chart keeps the indicator live while you inspect or change the chart.
• Save opens a review dialog for the name and optional description, then stores the source and selected inputs privately.
• Use the pencil beside a saved indicator to edit its details, or Load in Editor to inspect and change its source.

Signed-in users save to their private account library. Signed-out users save on the current device and can sign in later when they want account synchronization. Saving does not publish the indicator or expose its source to other users.

• The runtime evaluates only the current chart symbol and timeframe; multi-timeframe requests are not available yet.
• Inputs are numeric or boolean. Text, symbol and timeframe inputs are not available in this release.
• Browser and network APIs, imports, dynamic evaluation and strategy order calls are rejected.
• The runtime executes PineNode JavaScript DSL. The Pine Script importer converts its supported subset and reports syntax that still needs manual migration.
• Historical output depends on the loaded bars and data quality. Generated or custom indicators are research tools, not financial advice.

Start typing inside the editor and a dropdown surfaces matches across three layered sources:

• Indicator constructors — SMA, EMA,RSI, MACD, BollingerBands, ATR,Stochastic, ADX, OBV, VWAP,WilliamsR, ROC, CCI, plus the rolling averages, dispersion, range and momentum constructors used by the Pine importer. Each entry shows the signature in the detail column so you don't have to remember argument order.
• Strategy and indicator builder methods — pn.name,pn.indicator, pn.onBar, pn.param andpn.boolParam. (strategy is also accepted as a legacy alias.)
• Callback args — when the cursor is inside theonBar body, the destructured args (series,bar, barIndex, buy, sell,enterLong, enterShort,crossOver, crossUnder, plot,sentimentor) bubble to the top of the list. Outside onBar, the dropdown deprioritises them so you don't see runtime-only values when declaring top-level constants.

Hit Ctrl-Space (or ⌘-Space) anywhere to force the dropdown open even when the prefix is empty — useful when you want to browse the surface without remembering the first character.

Hover any DSL identifier and a tooltip shows the same documentation that powers the completion dropdown — a one-line summary plus, where useful, the function signature. The tooltip distinguishes:

• DSL primitives — new SMA(20) shows"Simple Moving Average" + signature.
• User declarations — local const /let / function bindings show the line they were declared on plus, during a debug session, their current value at the paused bar.
• Safety findings — any line the safety analyzer has a finding for surfaces the headline + explanation + suggested fix in the same tooltip surface, so you don't have to flip to the Safety Report to see what was flagged.

Several completions expand to a multi-cursor snippet template you can tab through. The big ones:

pn.onBar  → pn.onBar(({ series, buy, sell, crossOver, crossUnder }) => {
            ${1}
          });

pn.param  → pn.param('${label}', ${def}, ${min}, ${max}, ${step});

buy       → buy('${reason}');
sell      → sell('${reason}');

crossOver → crossOver(${1:a}, ${2:b})

Tab advances to the next placeholder; Esc drops out of the snippet so you can keep editing.

The editor parses your code as you type and pulls out every const,let, var, and function declaration. Those get merged into the completion dropdown so a variable you defined two lines ago auto-completes alongside the DSL surface, with no editor restart and no type annotations required.

Same goes for indicator instances: as soon as you write const ema20 = new EMA(20);, typing ema insideonBar offers ema20 with the right colour-coded variable icon.

As you type, the editor underlines structural issues (an indicator declared but never called .next(), a condition that fires neither buy norsell) and safety problems (repaint, lookahead, alert payload, etc.). Hover a squiggle for the title, explanation, and a fix.

The narrow column to the left of the line numbers is the breakpoint gutter — click a line to toggle a breakpoint. If you click without an active debug session, PineNode offers to start one and add the breakpoint in one step.

Click Debug below the editor. PineNode compiles the strategy, fetches bars for the configured ticker/timeframe, and pauses at bar 0. The transport controls:

• Step — advance exactly one bar.
• Continue — run forward until the next breakpoint (line, bar-index, or condition) or end of data.
• Restart — reset to bar 0 with the same bars and breakpoints.

When paused, the right panel shows the current bar's OHLC, the running equity, signals emitted this bar, locals captured via debug.watch(name, value), and any safety findings that touch the paused line.

Add an expression to the Watches panel and it's evaluated after every bar against(series, bar, barIndex, locals):

series.close(0) - series.close(1)
smaFast.value > smaSlow.value
locals.dpConfirm

Inside your strategy, call debug.watch('name', value) to surface any local value into the locals snapshot:

pn.onBar(({ series, buy, sentimentor }) => {
  const dpConfirm = sentimentor.darkPool?.ratio > 0.5;
  debug.watch('dpConfirm', dpConfirm);
  if (dpConfirm) buy('dp');
});

When your strategy throws an error during compilation or while running, PineNode rewrites the raw underlying message into something you can act on. Examples:

Raw  : ReferenceError: sma502 is not defined
Pine : "sma502" hasn't been declared
       — Check spelling against your params/indicators, or declare with
         const at the top level.

Raw  : TypeError: Cannot read properties of undefined (reading 'close')
Pine : series is missing on the first bar
       — Guard with: if (series.length < N) return;

The rewriter covers ~20 common patterns including Pine leftovers (ta.sma,strategy.entry), missing instantiations, indicator misuse, and JS syntax errors.

Parser and runtime diagnostics include the PineNode editor location asLine N:M. For example, an unresolved rsi call is reported at the identifier's exact line and column rather than as a location-freersi is not defined message.

Logic that reads values that change after the fact. Most common: instantiating an indicator inside onBar (which restarts the rolling window every bar), or reading series.close(N) without verifying series.lengthis at least N+1.

Logic that effectively peeks into the future. Pine's lookahead_onrequest.security calls are the canonical example. In PineNode, since there's no security-call surface, this family mostly catches Pine leftovers in imported code.

Orders or alerts that fire unconditionally every bar. Usually a missingif: the user wrote buy('…') at the top level ofonBar instead of inside a condition.

In imported Pine, this check applies to runtime alert() calls.alertcondition() is a declaration users can select when creating an alert, so it is not reported as though it fired by itself.

Three rules in this family today:

• Mutable reason — buy() / sell() /alert() reason strings that embed series.close() or other mutable OHLC / sentimentor values. The string captures the value at fire time, so live and backtest reasons disagree even when the logic is identical.
• Raw OHLC in alert payload — alert() messages that read series.close(0) (current-bar value) directly. Fine for closed-bar backtests today, but any future real-time / streaming mode will re-fire the alert mid-bar with a different number than the chart shows.
• Pine equivalents — when importing Pine, the same family fires on alert("… " + str.tostring(close)) as well as barealert(...) calls that reference close / high/ low / open without a barstate.isconfirmedguard.

The fix in every case is to either reference the previous (closed) bar viaseries.close(1) / close[1], or to wrap the side-effect in a bar-close guard.

Order-flow traps. Two buy() calls without an interveningsell() — the second is silently dropped. Pine'scalc_on_every_tick=true — backtest and live diverge. Pyramiding without an explicit limit.

Next to Import from TV Pine Script in the editor toolbar, the Ask Augur button offers Improve the strategy and Suggest backtest config, which open a draft with the current strategy source. It also offers Compare recorded versions and Follow recorded outcomes: read-only reviews of retained records, not the unsaved editor source. Review and submit the draft yourself; choosing a menu item does not run a test or start monitoring.

Augur lists your records before comparing selected versions or reviewing existing outcomes. See strategy history and published-history integrity for provenance, missing-fill handling and public-visibility limits.

Every safety finding card in the Analyze modal has its own Ask Augur button on the right side of the rule row. That dropdown shows the two finding-anchored intents: Fix the logic and Explain this warning. Clicking either packages the finding (rule id, line, severity, headline, explanation, suggested fix) alongside the strategy source into the seeded prompt — so the agent sees the exact warning the analyzer surfaced and doesn't have to guess which line you're asking about.

Warning at line 24 (unsafe): Indicator "smaFast" is instantiated inside onBar
Rule id: pn/repaint/indicator-in-onbar
Analyzer says: Indicators that hold a rolling window...
Suggested fix: Move the new SMA(...) outside the onBar callback...

The seeded prompt always includes the full strategy source inside a fenced```javascript block so Augur has the actual code to reason about, not a summary. You can review and edit the prompt before sending — the chat input is pre-populated, not auto-submitted.

Requires Node 18 or newer. Install globally with npm:

bash
npm install -g @sentimentor/pinenode-cli@1.3.1

# Verify the install
pn version   # → 1.3.1
pn help

The shipped binary is fully self-contained — the PineNode engine, transpiler, and safety analyzer are all bundled in. No additional Sentimentor checkout required.

If pn version reports something different from what npm view @sentimentor/pinenode-cli version shows, npm probably served a cached tarball. Force it:

bash
npm cache clean --force
npm install -g @sentimentor/pinenode-cli@1.3.1
which pn
pn version

The CLI is included with every Sentimentor subscription. Trial and free accounts get local backtests only against bars files you supply — a try-before-you-buy affordance. Pro unlocks historical-data fetch and Sentimentor data reads (sentiment, dark-pool, options flow). Elite adds the optimizer, cloud library (push/pull), and validated Alpaca Paper deployment; Trader includes the same CLI paper-deployment capability. Live brokerage support is planned for December 2026, with additional brokers to follow, and is not enabled. The token you generate inherits your current plan's capabilities automatically — no separate billing on the CLI side.

Generate one from /account/cli-tokens:

1. Run pn login — your browser opens the management page.
2. Click Generate token. The plaintext is shown once — copy it immediately.
3. Paste it at the CLI prompt. The token gets stored in ~/.config/sentimentor/credentials.json (mode 0600).

bash
# Interactive — opens the browser, prompts for the pasted token
pn login

# Non-interactive (CI) — skip the prompt, pass the token directly
pn login --token pn_live_••••••••••••••••••••

# Check what's saved + force a refresh of the capability cache
pn whoami
pn whoami --refresh

# Revoke the current token server-side + wipe the local file
pn logout

Local backtest against a bars file you supply — available on every plan, including Trial / Free. The strategy file is passed via --strategy so the sub-verb slot names the operation, not a file path.

Need a bars file to test with? Download sample-bars.json — 121 daily AAPL candles (~5 months), ready to drop into your working directory as bars.json and use in the examples below.

bash
# Short form — reads ./strategy.pinenode
pn backtest --bars bars.json

# Explicit local path
pn backtest --strategy other-strategy.pinenode --bars bars.json

# Cloud strategy by NAME — pulled + backtested in one step (Elite+)
pn backtest --strategy "SMA Cross + Sentimentor" --bars bars.json

# Cloud strategy by UUID — unambiguous when names clash (Elite+)
pn backtest --strategy be538db3-a925-4712-be9d-baf915dd9a70 --bars bars.json

# CSV bars + non-default capital
pn backtest --bars bars.csv --capital 50000

# Machine-readable single JSON object (good for CI assertions)
pn backtest --bars bars.json --json

# Every braille chart at once — equivalent to combining all --chart-*
pn backtest --bars bars.json --rich

Selective chart output. The --chart-* flags render individual sections of the rich report so you can compose exactly the view you need. Combine as many as you want; each flag is additive.

bash
# Just the equity + drawdown line charts
pn backtest --bars bars.json --chart-line

# Just the colored P/L distribution histogram
pn backtest --bars bars.json --chart-bar

# Just the price scatter with entry/exit markers (▲ ▼ ● ○)
pn backtest --bars bars.json --chart-scatter

# Just the top-drawdowns table
pn backtest --bars bars.json --chart-table

# Any combination is additive — line + histogram is a common pair
pn backtest --bars bars.json --chart-line --chart-bar

--chart-line covers both the equity curve and the drawdown curve because they share an x-axis and are read together. Every chart falls back cleanly on terminals without UTF-8 support.

Fetch bars and run in one shot — Pro, Elite, or Trader:

bash
# Uses ./strategy.pinenode by default; --strategy overrides
pn backtest --ticker NVDA --days 365 --timeframe 1d

# Same, plus inject Sentimentor's dark-pool / options-flow /
# sentiment inputs into the strategy before the bar loop runs
pn backtest --ticker NVDA --sentimentor

Pull historical OHLCV bars to a file, to a braille chart, or to stdout — Pro, Elite, or Trader. Three output modes, picked by which flag you set:

bash
# --out <file>  — write bars to disk (JSON or CSV by extension)
pn fetch --ticker AAPL --days 730 --timeframe 1d --out aapl.json
pn fetch --ticker NVDA --days 90  --timeframe 15m --out nvda.csv

# --chart-*     — render bars as a braille chart to stdout
pn fetch --ticker AAPL --days 730 --chart-line
pn fetch --ticker AAPL --days 730 --chart-line --chart-bar --chart-table
pn fetch --ticker AAPL --days 90 --timeframe 1h --chart-scatter

# (no flag)     — dump bars as JSON to stdout (pipeable)
pn fetch --ticker AAPL --days 30 | jq '.[0]'                     # peek at bar 0
pn fetch --ticker AAPL --days 30 > aapl.json                     # tee to a file

Chart flags on fetch mean: --chart-line is a connected close-price curve, --chart-bar is a per-bar volume histogram, --chart-scatter is a close-price dot per bar, and --chart-table is a summary of first / last / min / max / mean / stdev / % change. Combine any set for a composed view.

Expanded in v1.3.1. pn fetch, pn backtest --ticker …, and pn optimize target the stocks market by default — which also covers ETFs like SPY / QQQ / GLD since Polygon exposes those through the equities feed. Pick a different asset class with one of four mutually-exclusive flags:

Symbols are always in the bare form — the CLI adds Polygon's X: / C: / I: prefix behind the scenes based on the market flag. Passing more than one market flag is a validation error.

bash
# Stocks (default — no flag needed)
pn fetch --ticker AAPL --days 30 --out aapl.json
pn backtest --ticker NVDA --days 365 --strategy sma-cross.pinenode
pn optimize --ticker TSLA --days 90

# ETFs — same route as stocks
pn fetch --ticker SPY --days 30 --out spy.json
pn fetch --ticker QQQ --days 30 --chart-line

# Crypto
pn fetch --ticker BTCUSD --crypto --days 30 --out btc.json
pn fetch --ticker ETHUSD --crypto --days 30 | jq '.[0]'
pn backtest --ticker SOLUSD --crypto --days 90 --strategy momentum.pinenode
pn optimize --ticker BTCUSD --crypto --days 180

# Forex
pn fetch --ticker EURUSD --forex --days 30 --out eur.json
pn fetch --ticker USDJPY --forex --days 90 --timeframe 1h --chart-line
pn backtest --ticker GBPUSD --forex --days 365 --strategy trend.pinenode

# Indices
pn fetch --ticker SPX --indices --days 30 --out spx.json
pn fetch --ticker VIX --indices --days 90 --chart-line
pn optimize --ticker NDX --indices --days 365

When a fetch on the default stocks market returns zero bars, the CLI prints a hint suggesting the crypto / forex / indices flag — a common mistake is running pn fetch --ticker BTCUSD (no flag) and getting nothing back because BTCUSD isn't a stock.

Submit the strategy's pn.param() declarations to Sentimentor's bundled deterministic optimizer — Elite or Trader. It evaluates up to 2,000 combinations locally and ranks valid results by Sharpe, then return. The command accepts the same --crypto / --forex / --indicesmarket flags as fetch — see Market selection.

bash
# Use the param() bounds declared in the strategy itself
# (--strategy defaults to ./strategy.pinenode when omitted)
pn optimize --ticker NVDA --days 365

# Crypto — grid-search a momentum strategy on ETHUSD
pn optimize --ticker ETHUSD --crypto --days 180

# Override the search space with a grid spec file
pn optimize --ticker NVDA --grid grid.json --json

grid.json shape:

{
  "Fast Period": { "min": 5,  "max": 50,  "step": 5  },
  "Slow Period": { "min": 20, "max": 200, "step": 10 }
}

Version 1.3.1 exposes the web PineNode research lifecycle as headless commands. Validation uses the same server-owned discovery → purged rolling validation → one-time final lockbox protocol; later stages remain sealed when an earlier stage fails, and each failed rule is printed.

bash
pn validate --strategy strategy.pinenode --ticker SPY --days 3650 --embargo 5
pn analyze --strategy strategy.pinenode
pn debug --strategy strategy.pinenode --bars bars.json --break-bars 20,50 --watch "bar.close"
pn backtest --bars bars.json --params params.json

pn convert strategy.pine --out strategy.pinenode
# After reviewing a Degraded/Unsupported report:
pn convert strategy.pine --out strategy.pinenode --allow-degraded
pn indicator convert study.pine --out study.pinenode
pn indicator run study.pinenode --bars bars.json --out plots.json
pn library list

pn augur --prompt "Research a daily SPY trend hypothesis" --ticker SPY
pn augur --prompt "Reduce fragility" --strategy strategy.pinenode --out refined.pinenode

pn strategies rename <id> --name "SPY Trend v5"
pn forward --strategy <cloud-id> --ticker SPY
pn runners list
pn runners history <runner-id>
pn runners pause <runner-id> --strategy <cloud-id>

pn verify publish --strategy strategy.pinenode --ticker SPY
pn ledger --ticker SPY --passed-only

Round-trip strategies through your Sentimentor cloud library — Elite or Trader:

bash
# Push the local file to your cloud library (defaults to
# ./strategy.pinenode; --strategy overrides)
pn push --name "NVDA EMA Cross v3"

# List your saved strategies
pn pull

# Pull a specific strategy by id, write it to disk
pn pull <strategy-id> --out my-strategy.pinenode

PineNode CLI Alpaca Paper deployment is available on Elite and Trader. Connect the paper account under Profile → Broker Connections, then use the CLI to activate an eligible saved strategy. Web-app Alpaca Paper deployment is available on every plan, including Trial. Credentials stay encrypted on the server and are never returned to the browser or CLI. Broker-backed runners are limited to validated, long-only US-equity strategies, completed bars, market orders, day time-in-force, and the configured risk limits.

CLI deployment accepts a cloud strategy name or ID, never arbitrary local source. The server reconstructs the frozen parameters and verifies the saved code, ticker, timeframe, validated universe, configuration fingerprint, and consumed final-lockbox record before activating the runner:

bash
pn deploy --strategy "SPY Trend v4" --ticker SPY --paper \
  --max-order-notional 1000 \
  --max-orders-per-day 10 \
  --daily-loss-limit 250

# Pause future scans. This does not cancel accepted orders or close positions.
pn deploy stop <runner-id>

Code, parameters, initial capital, sizing, stops, direction, ticker, and timeframe remain frozen by validation. The three optional CLI limits above are operational guards, not research inputs. Local files and configuration-changing flags are rejected with instructions to save and revalidate first. --live is not available; live brokerage support is planned for December 2026, with additional broker integrations to follow. Orders use deterministic client IDs so a retry cannot intentionally submit the same completed-bar signal twice. Sentimentor reconciles accepted, partial, filled, rejected, expired, and canceled order states; repeated broker failures pause the runner. Disconnecting Alpaca pauses paper-backed runners and does not close positions or cancel pending orders.

See the dedicated Alpaca Paper setup, safeguards, monitoring and troubleshooting guide before activating a broker-backed runner.

Both --bars file.json and --bars file.csv are accepted.

JSON — array of OHLCV rows:

[
  { "time": 1709480400000, "open": 174.32, "high": 175.10, "low": 173.95, "close": 174.88, "volume": 1240500 },
  ...
]

CSV — header row required, column order free:

time,open,high,low,close,volume
2024-03-04T14:30:00Z,174.32,175.10,173.95,174.88,1240500
2024-03-04T14:31:00Z,174.88,175.05,174.40,174.61, 920100

time accepts Unix milliseconds, an integer string, or any ISO-8601 datetime — the CLI normalizes them all to ms.

Distinct exit codes for shell-script-friendly branching:

Sentimentor has three paid plans — Pro, Elite, and Trader — plus a Trial / Free state for users inside the 7-day trial window, after trial expiry, or with a cancelled / past-due subscription. The CLI ships with every plan; the gating rule is: Trial / Free can run local backtests against files you supply, Pro adds historical-data fetch + Sentimentor data reads, Elite adds the optimizer, cloud library, and Alpaca Paper deployment; Trader includes the same CLI paper capability. Live brokerage deployment is planned for December 2026, with additional brokers to follow, and is not currently available.

When the CLI tries to run a command your current plan doesn't cover, it exits with code 4 and a colored "Upgrade required" message that links straight to billing.