Handle TradingView Pine first-save recovery

Author: TayDa64

scripts/test-tradingview-pine-data-workflows.js

@@ -263,6 +263,8 @@ test('clipboard-only pine authoring plan rewrites into guarded continuation afte
   const saveInspect = freshInspect.continueActions.find((action) => action?.type === 'get_text' && action?.pineEvidenceMode === 'save-status');
   assert(saveInspect, 'fresh-script continuation should verify visible save status before applying');
   assert.strictEqual(saveInspect.continueOnPineLifecycleState, 'saved-state-verified');
+  assert(Array.isArray(saveInspect?.continueActionsByPineLifecycleState?.['save-required-before-apply']), 'save verification should branch into a first-save recovery path when TradingView requires a script name');
+  assert(saveInspect.continueActionsByPineLifecycleState['save-required-before-apply'].some((action) => action?.type === 'type' && /Momentum Confidence/.test(String(action?.text || ''))), 'first-save recovery should derive a script name from the Pine payload');
   assert(saveInspect.continueActions.some((action) => action?.type === 'key' && String(action?.key || '').toLowerCase() === 'ctrl+enter'), 'save-verified continuation should add the script to the chart');
   assert(saveInspect.continueActions.some((action) => action?.type === 'get_text' && action?.pineEvidenceMode === 'compile-result'), 'save-verified continuation should gather compile-result feedback after add-to-chart');
 });

scripts/test-windows-observation-flow.js

@@ -1350,8 +1350,9 @@ async function run() {
     assert(execResult.results.some((result) => result?.pineContinuationInjected), 'inspect step should inject continuation actions');
   });
 
-  await testAsync('safe pine authoring blocks add-to-chart when save evidence is missing', async () => {
+  await testAsync('safe pine authoring recovers through first-save naming before add-to-chart', async () => {
     const executed = [];
+    let saveStatusReads = 0;
 
     const foregroundSequence = [
       { success: true, hwnd: 777, title: 'TradingView', processName: 'tradingview', windowKind: 'main' },
@@ -1392,24 +1393,38 @@ async function run() {
           };
         }
         if (action?.type === 'get_text' && action?.pineEvidenceMode === 'save-status') {
+          saveStatusReads += 1;
           return {
             success: true,
             action: 'get_text',
-            message: 'save still required',
+            message: saveStatusReads === 1 ? 'save still required' : 'save verified',
             pineStructuredSummary: {
               evidenceMode: 'save-status',
-              lifecycleState: 'save-required-before-apply'
+              lifecycleState: saveStatusReads === 1 ? 'save-required-before-apply' : 'saved-state-verified'
+            }
+          };
+        }
+        if (action?.type === 'get_text' && action?.pineEvidenceMode === 'compile-result') {
+          return {
+            success: true,
+            action: 'get_text',
+            message: 'compiled successfully',
+            pineStructuredSummary: {
+              evidenceMode: 'compile-result',
+              lifecycleState: 'apply-result-verified'
             }
           };
         }
         return { success: true, action: action.type, message: 'ok' };
       }
     }));
 
-    assert.strictEqual(execResult.success, false, 'Execution should stop when save evidence is missing');
+    assert.strictEqual(execResult.success, true, 'Execution should recover after the first-save naming flow');
     assert(executed.includes('key:ctrl+s'), 'Save should still be attempted');
-    assert(!executed.includes('key:ctrl+enter'), 'Add-to-chart should be blocked without visible save evidence');
-    assert(execResult.results.some((result) => /do not add it to the chart yet/i.test(String(result?.error || ''))), 'Failure should explain that save verification blocked add-to-chart');
+    assert(executed.includes('type'), 'First-save recovery should type the derived script name');
+    assert(executed.includes('key:enter'), 'First-save recovery should confirm the save dialog');
+    assert(executed.includes('key:ctrl+enter'), 'Add-to-chart should resume only after save evidence is re-verified');
+    assert.strictEqual(saveStatusReads, 2, 'Save status should be checked before and after the first-save recovery');
   });
 
   await testAsync('compile-result corruption signal stops pine workflow with grounded editor-target failure', async () => {

src/main/ai-service.js

@@ -5242,8 +5242,10 @@ async function executeActions(actionData, onAction = null, onScreenshot = null,
     if (
       result.success
       && effectiveAction.type === 'get_text'
-      && Array.isArray(action.continueActions)
-      && action.continueActions.length > 0
+      && (
+        (Array.isArray(action.continueActions) && action.continueActions.length > 0)
+        || (action.continueActionsByPineLifecycleState && typeof action.continueActionsByPineLifecycleState === 'object')
+      )
     ) {
       const observedPineState = String(result?.pineStructuredSummary?.editorVisibleState || '').trim().toLowerCase();
       const expectedPineState = String(action?.continueOnPineEditorState || '').trim().toLowerCase();
@@ -5275,6 +5277,12 @@ async function executeActions(actionData, onAction = null, onScreenshot = null,
 
       const observedPineLifecycleState = String(result?.pineStructuredSummary?.lifecycleState || '').trim().toLowerCase();
       const expectedPineLifecycleState = String(action?.continueOnPineLifecycleState || '').trim().toLowerCase();
+      const lifecycleStateContinuations = action?.continueActionsByPineLifecycleState && typeof action.continueActionsByPineLifecycleState === 'object'
+        ? action.continueActionsByPineLifecycleState
+        : null;
+      const matchedLifecycleContinuation = lifecycleStateContinuations
+        ? lifecycleStateContinuations[observedPineLifecycleState] || lifecycleStateContinuations['*'] || null
+        : null;
 
       if (result.success && observedPineLifecycleState && expectedPineLifecycleState && observedPineLifecycleState === expectedPineLifecycleState) {
         const continuationActions = action.continueActions.map((step) => {
@@ -5291,6 +5299,19 @@ async function executeActions(actionData, onAction = null, onScreenshot = null,
           result.pineContinuationLifecycleState = observedPineLifecycleState;
           result.pineContinuationCount = continuationActions.length;
         }
+      } else if (result.success && observedPineLifecycleState && Array.isArray(matchedLifecycleContinuation) && matchedLifecycleContinuation.length > 0) {
+        const continuationActions = matchedLifecycleContinuation.map((step) => {
+          try {
+            return JSON.parse(JSON.stringify(step));
+          } catch {
+            return { ...step };
+          }
+        });
+
+        actionData.actions.splice(i + 1, 0, ...continuationActions);
+        result.pineContinuationInjected = true;
+        result.pineContinuationLifecycleState = observedPineLifecycleState;
+        result.pineContinuationCount = continuationActions.length;
       } else if (result.success && action.haltOnPineLifecycleStateMismatch) {
         const mismatchReasons = action?.pineLifecycleMismatchReasons && typeof action.pineLifecycleMismatchReasons === 'object'
           ? action.pineLifecycleMismatchReasons

src/main/tradingview/pine-workflows.js

@@ -155,6 +155,39 @@ function isPineSaveStep(action) {
     || /\bsave\b.{0,20}\bscript\b/i.test(combined);
 }
 
+function extractPineDeclarationTitle(text = '') {
+  const match = String(text || '').match(/\b(?:indicator|strategy|library)\s*\(\s*["'`](.*?)["'`]/i);
+  return String(match?.[1] || '').trim();
+}
+
+function sanitizePineScriptName(value = '') {
+  return String(value || '')
+    .replace(/\s+/g, ' ')
+    .replace(/[<>:"/\\|?*\u0000-\u001f]+/g, ' ')
+    .trim()
+    .slice(0, 120);
+}
+
+function inferSafePineScriptName(actions = [], raw = '') {
+  const source = Array.isArray(actions) ? actions : [];
+  for (const action of source) {
+    const type = getNormalizedActionType(action);
+    if (type === 'type') {
+      const title = sanitizePineScriptName(extractPineDeclarationTitle(action.text));
+      if (title) return title;
+    }
+    if (type === 'run_command') {
+      const title = sanitizePineScriptName(extractPineDeclarationTitle(action.command));
+      if (title) return title;
+    }
+  }
+
+  const messageTitle = sanitizePineScriptName(String(raw || '').match(/\b(?:called|named)\s+["'`](.*?)["'`]/i)?.[1] || '');
+  if (messageTitle) return messageTitle;
+
+  return 'Liku Pine Script';
+}
+
 function shouldAutoAddPineScriptToChart(raw = '', actions = []) {
   if (Array.isArray(actions) && actions.some((action) => isPineAddToChartStep(action))) {
     return true;
@@ -206,6 +239,8 @@ function buildSafePineAuthoringContinuationSteps(actions = [], intent = {}, raw
     return [];
   }
 
+  const derivedScriptName = inferSafePineScriptName(payloadSteps, raw);
+
   const applyContinuationSteps = [];
   if (addToChartSteps.length > 0) {
     applyContinuationSteps.push(...addToChartSteps);
@@ -258,6 +293,37 @@ function buildSafePineAuthoringContinuationSteps(actions = [], intent = {}, raw
       pineEvidenceMode: 'save-status',
       continueOnPineLifecycleState: 'saved-state-verified',
       continueActions: applyContinuationSteps,
+      continueActionsByPineLifecycleState: {
+        'save-required-before-apply': [
+          { type: 'wait', ms: 180 },
+          {
+            type: 'type',
+            text: derivedScriptName,
+            reason: `Provide a Pine script name in the TradingView first-save flow: ${derivedScriptName}`
+          },
+          { type: 'wait', ms: 120 },
+          {
+            type: 'key',
+            key: 'enter',
+            reason: 'Confirm the TradingView Pine first-save flow after entering the script name'
+          },
+          { type: 'wait', ms: 450 },
+          {
+            type: 'get_text',
+            text: 'Pine Editor',
+            reason: 'Re-verify visible Pine save-state evidence after naming the script',
+            pineEvidenceMode: 'save-status',
+            continueOnPineLifecycleState: 'saved-state-verified',
+            continueActions: applyContinuationSteps,
+            haltOnPineLifecycleStateMismatch: true,
+            pineLifecycleMismatchReasons: {
+              'save-required-before-apply': 'TradingView still shows save-required state after naming the script; stop before applying it to the chart.',
+              'editor-target-corrupt': 'Visible Pine output suggests editor-target corruption during save; stop before applying the script.',
+              '': 'The Pine save state could not be verified after naming the script; do not add it to the chart yet.'
+            }
+          }
+        ]
+      },
       haltOnPineLifecycleStateMismatch: true,
       pineLifecycleMismatchReasons: {
         'save-required-before-apply': 'Visible save confirmation was not observed after saving the Pine script; do not add it to the chart yet.',