Milestone 4: add TradingView Pine verification workflows

Author: TayDa64

docs/CHAT_CONTINUITY_IMPLEMENTATION_PLAN.md

@@ -1073,12 +1073,14 @@ node scripts/test-session-intent-state.js
 - extracted deterministic TradingView alert workflow shaping to `src/main/tradingview/alert-workflows.js`
 - extracted TradingView chart verification plus timeframe/symbol/watchlist workflow shaping to `src/main/tradingview/chart-verification.js`
 - extracted verification-first TradingView drawing/object-tree surface workflow shaping to `src/main/tradingview/drawing-workflows.js`
+- extracted verification-first TradingView Pine Editor surface workflow shaping to `src/main/tradingview/pine-workflows.js`
 - extracted reusable post-key observation checkpoint helpers to `src/main/ai-service/observation-checkpoints.js`
 - added direct module regressions in `scripts/test-tradingview-app-profile.js` and `scripts/test-tradingview-verification.js`
 - added direct indicator-workflow regression coverage in `scripts/test-tradingview-indicator-workflows.js`
 - added direct alert-workflow regression coverage in `scripts/test-tradingview-alert-workflows.js`
 - added direct chart-verification regression coverage in `scripts/test-tradingview-chart-verification.js`
 - added direct drawing-workflow regression coverage in `scripts/test-tradingview-drawing-workflows.js`
+- added direct Pine workflow regression coverage in `scripts/test-tradingview-pine-workflows.js`
 
 **Objective**
 - formalize reusable TradingView workflow modules around alerts, indicators, and chart verification

scripts/test-bug-fixes.js

@@ -254,6 +254,7 @@ test('ai-service gates TradingView follow-up typing on post-key observation chec
   const tradingViewAlertPath = path.join(__dirname, '..', 'src', 'main', 'tradingview', 'alert-workflows.js');
   const tradingViewChartPath = path.join(__dirname, '..', 'src', 'main', 'tradingview', 'chart-verification.js');
   const tradingViewDrawingPath = path.join(__dirname, '..', 'src', 'main', 'tradingview', 'drawing-workflows.js');
+  const tradingViewPinePath = path.join(__dirname, '..', 'src', 'main', 'tradingview', 'pine-workflows.js');
   const fs = require('fs');
 
   const aiServiceContent = fs.readFileSync(aiServicePath, 'utf8');
@@ -263,6 +264,7 @@ test('ai-service gates TradingView follow-up typing on post-key observation chec
   const tradingViewAlertContent = fs.readFileSync(tradingViewAlertPath, 'utf8');
   const tradingViewChartContent = fs.readFileSync(tradingViewChartPath, 'utf8');
   const tradingViewDrawingContent = fs.readFileSync(tradingViewDrawingPath, 'utf8');
+  const tradingViewPineContent = fs.readFileSync(tradingViewPinePath, 'utf8');
 
   assert(aiServiceContent.includes("require('./ai-service/observation-checkpoints')"), 'ai-service should consume the extracted observation checkpoint helper module');
   assert(observationCheckpointContent.includes('inferKeyObservationCheckpoint'), 'Observation checkpoint module should infer TradingView post-key checkpoints');
@@ -274,6 +276,7 @@ test('ai-service gates TradingView follow-up typing on post-key observation chec
   assert(aiServiceContent.includes("require('./tradingview/alert-workflows')"), 'ai-service should consume the extracted TradingView alert workflow helper');
   assert(aiServiceContent.includes("require('./tradingview/chart-verification')"), 'ai-service should consume the extracted TradingView chart verification helper');
   assert(aiServiceContent.includes("require('./tradingview/drawing-workflows')"), 'ai-service should consume the extracted TradingView drawing workflow helper');
+  assert(aiServiceContent.includes("require('./tradingview/pine-workflows')"), 'ai-service should consume the extracted TradingView Pine workflow helper');
   assert(tradingViewVerificationContent.includes("classification === 'panel-open'"), 'TradingView checkpoints should recognize panel-open flows such as Pine or DOM');
   assert(tradingViewVerificationContent.includes('pine editor'), 'TradingView checkpoints should ground Pine Editor workflows');
   assert(tradingViewVerificationContent.includes('depth of market'), 'TradingView checkpoints should ground DOM workflows');
@@ -287,6 +290,8 @@ test('ai-service gates TradingView follow-up typing on post-key observation chec
   assert(tradingViewChartContent.includes("key: 'enter'"), 'TradingView chart verification workflows should confirm timeframe changes with enter');
   assert(tradingViewDrawingContent.includes("target: 'object-tree'"), 'TradingView drawing workflows should encode object-tree verification metadata');
   assert(tradingViewDrawingContent.includes("kind: intent.verifyKind"), 'TradingView drawing workflows should preserve verification-first surface contracts');
+  assert(tradingViewPineContent.includes("target: 'pine-editor'"), 'TradingView Pine workflows should encode pine-editor verification metadata');
+  assert(tradingViewPineContent.includes('requiresObservedChange'), 'TradingView Pine workflows should gate follow-up typing on observed panel changes');
 });
 
 test('ai-service treats TradingView DOM order-entry actions as high risk', () => {

scripts/test-tradingview-pine-workflows.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+const assert = require('assert');
+const path = require('path');
+
+const {
+  inferTradingViewPineIntent,
+  buildTradingViewPineWorkflowActions,
+  maybeRewriteTradingViewPineWorkflow
+} = require(path.join(__dirname, '..', 'src', 'main', 'tradingview', 'pine-workflows.js'));
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`PASS ${name}`);
+  } catch (error) {
+    console.error(`FAIL ${name}`);
+    console.error(error.stack || error.message);
+    process.exitCode = 1;
+  }
+}
+
+test('inferTradingViewPineIntent recognizes Pine Editor surface requests', () => {
+  const intent = inferTradingViewPineIntent('open pine editor in tradingview', [
+    { type: 'key', key: 'ctrl+e' }
+  ]);
+
+  assert(intent, 'intent should be inferred');
+  assert.strictEqual(intent.appName, 'TradingView');
+  assert.strictEqual(intent.surfaceTarget, 'pine-editor');
+  assert.strictEqual(intent.verifyKind, 'panel-visible');
+});
+
+test('buildTradingViewPineWorkflowActions wraps the opener with panel verification', () => {
+  const actions = buildTradingViewPineWorkflowActions({
+    appName: 'TradingView',
+    surfaceTarget: 'pine-editor',
+    verifyKind: 'panel-visible',
+    openerIndex: 0,
+    requiresObservedChange: true
+  }, [
+    { type: 'key', key: 'ctrl+e', reason: 'Open Pine Editor' },
+    { type: 'type', text: 'strategy("test")', reason: 'Type script' }
+  ]);
+
+  assert.strictEqual(actions[0].type, 'bring_window_to_front');
+  assert.strictEqual(actions[2].type, 'key');
+  assert.strictEqual(actions[2].verify.kind, 'panel-visible');
+  assert.strictEqual(actions[2].verify.target, 'pine-editor');
+  assert.strictEqual(actions[2].verify.requiresObservedChange, true);
+  assert.strictEqual(actions[4].type, 'type');
+});
+
+test('maybeRewriteTradingViewPineWorkflow rewrites low-signal Pine Editor opener plans', () => {
+  const rewritten = maybeRewriteTradingViewPineWorkflow([
+    { type: 'key', key: 'ctrl+e' },
+    { type: 'type', text: 'plot(close)' }
+  ], {
+    userMessage: 'open pine editor in tradingview and type plot(close)'
+  });
+
+  assert(Array.isArray(rewritten), 'pine rewrite should return an action array');
+  assert.strictEqual(rewritten[0].type, 'bring_window_to_front');
+  assert.strictEqual(rewritten[2].type, 'key');
+  assert.strictEqual(rewritten[2].verify.target, 'pine-editor');
+  assert.strictEqual(rewritten[2].verify.requiresObservedChange, true);
+  assert.strictEqual(rewritten[4].type, 'type');
+  assert.strictEqual(rewritten[4].text, 'plot(close)');
+});
+
+test('TradingView Pine workflow does not hijack authoring-only prompts', () => {
+  const rewritten = maybeRewriteTradingViewPineWorkflow([
+    { type: 'key', key: 'ctrl+e' }
+  ], {
+    userMessage: 'write a pine script for tradingview'
+  });
+
+  assert.strictEqual(rewritten, null, 'authoring-only prompts should not be auto-rewritten into an opener flow');
+});

scripts/test-windows-observation-flow.js

@@ -246,6 +246,25 @@ async function run() {
     assert.strictEqual(rewritten[4].text, 'trend line');
   });
 
+  await testAsync('low-signal TradingView Pine Editor request wraps the opener with bounded panel verification', async () => {
+    const rewritten = aiService.rewriteActionsForReliability([
+      { type: 'key', key: 'ctrl+e' },
+      { type: 'type', text: 'plot(close)' }
+    ], {
+      userMessage: 'open pine editor in tradingview and type plot(close)'
+    });
+
+    assert(Array.isArray(rewritten), 'pine rewrite should return an action array');
+    assert.strictEqual(rewritten[0].type, 'bring_window_to_front');
+    assert.strictEqual(rewritten[0].processName, 'tradingview');
+    assert.strictEqual(rewritten[2].type, 'key');
+    assert.strictEqual(rewritten[2].verify.kind, 'panel-visible');
+    assert.strictEqual(rewritten[2].verify.target, 'pine-editor');
+    assert.strictEqual(rewritten[2].verify.requiresObservedChange, true);
+    assert.strictEqual(rewritten[4].type, 'type');
+    assert.strictEqual(rewritten[4].text, 'plot(close)');
+  });
+
   await testAsync('TradingView alert accelerator blocks follow-up typing when no dialog change is observed', async () => {
     const executed = [];
     const foregroundSequence = [
@@ -810,6 +829,57 @@ async function run() {
     });
   });
 
+  await testAsync('explicit TradingView Pine Editor contracts gate typing on observed panel change', async () => {
+    const executed = [];
+    const foregroundSequence = [
+      { success: true, hwnd: 777, title: 'TradingView', processName: 'tradingview', windowKind: 'main' },
+      { success: true, hwnd: 777, title: 'Pine Editor - TradingView', processName: 'tradingview', windowKind: 'main' },
+      { success: true, hwnd: 777, title: 'Pine Editor - TradingView', processName: 'tradingview', windowKind: 'main' },
+      { success: true, hwnd: 777, title: 'Pine Editor - TradingView', processName: 'tradingview', windowKind: 'main' }
+    ];
+
+    await withPatchedSystemAutomation({
+      resolveWindowHandle: async (action) => action?.processName === 'tradingview' ? 777 : 0,
+      getForegroundWindowInfo: async () => foregroundSequence.shift() || { success: true, hwnd: 777, title: 'Pine Editor - TradingView', processName: 'tradingview', windowKind: 'main' },
+      focusWindow: async () => ({ success: true }),
+      getRunningProcessesByNames: async () => ([{ pid: 4242, processName: 'tradingview', mainWindowTitle: 'TradingView', startTime: '2026-03-23T00:00:00Z' }])
+    }, async () => {
+      const execResult = await aiService.executeActions({
+        thought: 'Open TradingView Pine Editor and type a script',
+        verification: 'TradingView should show the Pine Editor before typing',
+        actions: [
+          { type: 'focus_window', title: 'TradingView', processName: 'tradingview' },
+          {
+            type: 'key',
+            key: 'ctrl+e',
+            reason: 'Open TradingView Pine Editor',
+            verify: {
+              kind: 'panel-visible',
+              appName: 'TradingView',
+              target: 'pine-editor',
+              keywords: ['pine', 'pine editor', 'script'],
+              requiresObservedChange: true
+            }
+          },
+          { type: 'type', text: 'plot(close)', reason: 'Type Pine script' }
+        ]
+      }, null, null, {
+        userMessage: 'open pine editor in tradingview and type plot(close)',
+        actionExecutor: async (action) => {
+          executed.push(action.type);
+          return { success: true, action: action.type, message: 'executed' };
+        }
+      });
+
+      assert.strictEqual(execResult.success, true, 'Execution should proceed after the Pine Editor surface is observed');
+      assert.deepStrictEqual(executed, ['focus_window', 'key', 'type'], 'Typing should continue only after the Pine panel transition is verified');
+      assert.strictEqual(execResult.observationCheckpoints.length, 1, 'A post-key observation checkpoint should be returned');
+      assert.strictEqual(execResult.observationCheckpoints[0].verified, true, 'The Pine checkpoint should pass after panel observation');
+      assert.strictEqual(execResult.observationCheckpoints[0].classification, 'panel-open', 'Pine Editor should verify as a panel-open checkpoint');
+      assert.strictEqual(execResult.observationCheckpoints[0].foreground.hwnd, 777, 'Checkpoint should preserve the TradingView main window handle');
+    });
+  });
+
   await testAsync('TradingView DOM order-entry actions are elevated to high risk', async () => {
     const safety = aiService.analyzeActionSafety(
       { type: 'click', reason: 'Place limit order from DOM order book' },

src/main/ai-service.js

@@ -108,6 +108,9 @@ const {
 const {
   maybeRewriteTradingViewDrawingWorkflow
 } = require('./tradingview/drawing-workflows');
+const {
+  maybeRewriteTradingViewPineWorkflow
+} = require('./tradingview/pine-workflows');
 const {
   createObservationCheckpointRuntime
 } = require('./ai-service/observation-checkpoints');
@@ -3068,6 +3071,11 @@ function rewriteActionsForReliability(actions, context = {}) {
     return tradingViewDrawingRewrite;
   }
 
+  const tradingViewPineRewrite = maybeRewriteTradingViewPineWorkflow(actions, { userMessage });
+  if (tradingViewPineRewrite) {
+    return tradingViewPineRewrite;
+  }
+
   const tradingViewIndicatorRewrite = maybeRewriteTradingViewIndicatorWorkflow(actions, { userMessage });
   if (tradingViewIndicatorRewrite) {
     return tradingViewIndicatorRewrite;

src/main/tradingview/pine-workflows.js

@@ -0,0 +1,158 @@
+const { buildVerifyTargetHintFromAppName } = require('./app-profile');
+const { extractTradingViewObservationKeywords } = require('./verification');
+
+function normalizeTextForMatch(value) {
+  return String(value || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, ' ')
+    .trim();
+}
+
+function mergeUnique(values = []) {
+  return Array.from(new Set((Array.isArray(values) ? values : [values])
+    .flat()
+    .map((value) => String(value || '').trim())
+    .filter(Boolean)));
+}
+
+function inferPineSurfaceTarget(raw = '') {
+  const normalized = normalizeTextForMatch(raw);
+  if (!normalized) return null;
+
+  if (/\bpine logs\b/.test(normalized)) {
+    return { target: 'pine-logs', kind: 'panel-visible' };
+  }
+  if (/\bprofiler\b/.test(normalized)) {
+    return { target: 'pine-profiler', kind: 'panel-visible' };
+  }
+  if (/\bversion history\b/.test(normalized)) {
+    return { target: 'pine-version-history', kind: 'panel-visible' };
+  }
+  if (/\bpine editor\b|\bpine\b|\bscript\b|\bscripts\b/.test(normalized)) {
+    return { target: 'pine-editor', kind: 'panel-visible' };
+  }
+
+  return null;
+}
+
+function inferTradingViewPineIntent(userMessage = '', actions = []) {
+  const raw = String(userMessage || '').trim();
+  if (!raw) return null;
+
+  const mentionsTradingView = /\btradingview|trading view\b/i.test(raw)
+    || (Array.isArray(actions) && actions.some((action) => /tradingview/i.test(String(action?.title || '')) || /tradingview/i.test(String(action?.processName || ''))));
+  if (!mentionsTradingView) return null;
+
+  const mentionsPineSurface = /\bpine editor\b|\bpine logs\b|\bprofiler\b|\bversion history\b|\bpine\s+script\b|\bpine\b/i.test(raw);
+  const mentionsSafeOpenIntent = /\b(open|show|focus|switch|activate|bring up|display|launch)\b/i.test(raw);
+  const mentionsUnsafeAuthoringOnly = /\b(write|create|generate|build|draft)\b/i.test(raw) && !mentionsSafeOpenIntent;
+
+  if (!mentionsPineSurface || mentionsUnsafeAuthoringOnly) {
+    return null;
+  }
+
+  const openerTypes = new Set(['key', 'click', 'double_click', 'right_click']);
+  const openerIndex = Array.isArray(actions)
+    ? actions.findIndex((action) => openerTypes.has(action?.type))
+    : -1;
+  if (openerIndex < 0) return null;
+
+  const nextAction = openerIndex >= 0 ? actions[openerIndex + 1] || null : null;
+  const surface = inferPineSurfaceTarget(raw);
+  if (!surface) return null;
+
+  const existingWorkflowSignal = Array.isArray(actions) && actions.some((action) => /pine/.test(String(action?.verify?.target || '')));
+
+  return {
+    appName: 'TradingView',
+    surfaceTarget: surface.target,
+    verifyKind: surface.kind,
+    openerIndex,
+    existingWorkflowSignal,
+    requiresObservedChange: nextAction?.type === 'type',
+    reason: surface.target === 'pine-logs'
+      ? 'Open TradingView Pine Logs with verification'
+      : surface.target === 'pine-profiler'
+        ? 'Open TradingView Pine Profiler with verification'
+        : surface.target === 'pine-version-history'
+          ? 'Open TradingView Pine version history with verification'
+          : 'Open TradingView Pine Editor with verification'
+  };
+}
+
+function buildTradingViewPineWorkflowActions(intent = {}, actions = []) {
+  if (!Array.isArray(actions) || intent.openerIndex < 0 || intent.openerIndex >= actions.length) return null;
+
+  const opener = actions[intent.openerIndex];
+  const verifyTarget = buildVerifyTargetHintFromAppName(intent.appName || 'TradingView');
+  const expectedKeywords = mergeUnique([
+    'pine',
+    'pine editor',
+    intent.surfaceTarget,
+    extractTradingViewObservationKeywords(`open ${intent.surfaceTarget} in tradingview`),
+    verifyTarget.pineKeywords,
+    verifyTarget.dialogKeywords,
+    verifyTarget.titleHints
+  ]);
+
+  const rewritten = [
+    {
+      type: 'bring_window_to_front',
+      title: 'TradingView',
+      processName: 'tradingview',
+      reason: 'Focus TradingView before the Pine workflow',
+      verifyTarget
+    },
+    { type: 'wait', ms: 650 },
+    {
+      ...opener,
+      reason: opener?.reason || intent.reason,
+      verify: opener?.verify || {
+        kind: intent.verifyKind,
+        appName: 'TradingView',
+        target: intent.surfaceTarget,
+        keywords: expectedKeywords,
+        requiresObservedChange: !!intent.requiresObservedChange
+      },
+      verifyTarget
+    }
+  ];
+
+  if (!rewritten[2].verifyTarget) {
+    rewritten[2].verifyTarget = verifyTarget;
+  }
+
+  const trailing = actions.slice(intent.openerIndex + 1)
+    .filter((action) => action && typeof action === 'object' && action.type !== 'screenshot');
+
+  if (trailing.length > 0 && trailing[0]?.type !== 'wait') {
+    rewritten.push({ type: 'wait', ms: 220 });
+  }
+
+  return rewritten.concat(trailing);
+}
+
+function maybeRewriteTradingViewPineWorkflow(actions, context = {}) {
+  if (!Array.isArray(actions) || actions.length === 0) return null;
+
+  const intent = inferTradingViewPineIntent(context.userMessage || '', actions);
+  if (!intent || intent.existingWorkflowSignal || intent.openerIndex < 0) return null;
+
+  const lowSignalTypes = new Set(['bring_window_to_front', 'focus_window', 'key', 'click', 'double_click', 'right_click', 'type', 'wait', 'screenshot']);
+  const lowSignal = actions.every((action) => lowSignalTypes.has(action?.type));
+  const tinyOrFragmented = actions.length <= 4;
+  const screenshotFirst = actions[0]?.type === 'screenshot';
+  const lacksPineVerification = !actions.some((action) => /pine/.test(String(action?.verify?.target || '')));
+
+  if (!lowSignal || (!tinyOrFragmented && !screenshotFirst && !lacksPineVerification)) {
+    return null;
+  }
+
+  return buildTradingViewPineWorkflowActions(intent, actions);
+}
+
+module.exports = {
+  inferTradingViewPineIntent,
+  buildTradingViewPineWorkflowActions,
+  maybeRewriteTradingViewPineWorkflow
+};