Structure Pine editor diagnostics summaries

Author: TayDa64

scripts/test-bug-fixes.js

@@ -415,8 +415,15 @@ test('ai-service gates TradingView follow-up typing on post-key observation chec
   assert(tradingViewPineContent.includes("text: 'Pine Editor'"), 'TradingView Pine workflows should support bounded Pine Editor status/output readback');
   assert(tradingViewPineContent.includes('wantsEvidenceReadback'), 'TradingView Pine workflows should detect Pine evidence-gathering requests');
   assert(systemAutomationContent.includes('buildPineEditorSafeAuthoringSummary'), 'system-automation should structure Pine Editor safe-authoring inspection summaries');
+  assert(systemAutomationContent.includes('buildPineEditorDiagnosticsStructuredSummary'), 'system-automation should structure Pine Editor diagnostics summaries');
   assert(systemAutomationContent.includes("pineEvidenceMode === 'safe-authoring-inspect'"), 'system-automation should attach structured Pine summaries for safe-authoring-inspect readbacks');
+  assert(systemAutomationContent.includes("action?.pineEvidenceMode === 'compile-result'"), 'system-automation should structure compile-result Pine Editor reads');
+  assert(systemAutomationContent.includes("action?.pineEvidenceMode === 'diagnostics'"), 'system-automation should structure diagnostics Pine Editor reads');
+  assert(systemAutomationContent.includes("action?.pineEvidenceMode === 'line-budget'"), 'system-automation should structure line-budget Pine Editor reads');
+  assert(systemAutomationContent.includes("action?.pineEvidenceMode === 'generic-status'"), 'system-automation should structure generic-status Pine Editor reads');
   assert(sessionIntentStateContent.includes('pineAuthoringState'), 'session intent continuity context should expose Pine authoring state');
+  assert(sessionIntentStateContent.includes('pineCompileStatus'), 'session intent continuity context should expose Pine compile status');
+  assert(sessionIntentStateContent.includes('Visible Pine compiler errors are present'), 'session intent continuity should recommend fixing visible compiler errors first');
   assert(sessionIntentStateContent.includes('avoid overwriting it implicitly'), 'session intent continuity should recommend non-destructive Pine next steps when script content is already visible');
   assert(chatContinuityStateContent.includes('normalizePineStructuredSummary'), 'chat continuity mapper should preserve Pine structured summary fields');
   assert(tradingViewPaperContent.includes("target: 'paper-trading-panel'"), 'TradingView Paper workflows should encode paper-trading-panel verification metadata');

scripts/test-chat-continuity-state.js

@@ -204,3 +204,52 @@ test('continuity mapper preserves Pine safe-authoring structured summary facts',
     'script-body-visible'
   ]);
 });
+
+test('continuity mapper preserves Pine diagnostics structured summary facts', () => {
+  const turnRecord = buildChatContinuityTurnRecord({
+    actionData: {
+      thought: 'Inspect Pine diagnostics',
+      actions: [
+        { type: 'focus_window', title: 'TradingView', processName: 'tradingview' },
+        { type: 'key', key: 'ctrl+e', reason: 'Open Pine Editor', verify: { kind: 'panel-visible', target: 'pine-editor' } },
+        { type: 'get_text', text: 'Pine Editor', reason: 'Read visible diagnostics' }
+      ]
+    },
+    execResult: {
+      success: true,
+      results: [
+        { success: true, action: 'focus_window', message: 'focused' },
+        { success: true, action: 'key', message: 'editor opened' },
+        {
+          success: true,
+          action: 'get_text',
+          message: 'diagnostics inspected',
+          pineStructuredSummary: {
+            evidenceMode: 'diagnostics',
+            compileStatus: 'errors-visible',
+            errorCountEstimate: 1,
+            warningCountEstimate: 1,
+            lineBudgetSignal: 'unknown-line-budget',
+            statusSignals: ['compile-errors-visible', 'warnings-visible'],
+            topVisibleDiagnostics: ['Compiler error at line 42: mismatched input.', 'Warning: script has unused variable.'],
+            compactSummary: 'status=errors-visible | errors=1 | warnings=1'
+          }
+        }
+      ]
+    },
+    details: {
+      userMessage: 'open pine editor in tradingview and check diagnostics',
+      executionIntent: 'Inspect Pine diagnostics.',
+      nextRecommendedStep: 'Fix the visible compiler errors before continuing.'
+    }
+  });
+
+  assert.strictEqual(turnRecord.results[2].pineStructuredSummary.compileStatus, 'errors-visible');
+  assert.strictEqual(turnRecord.results[2].pineStructuredSummary.errorCountEstimate, 1);
+  assert.strictEqual(turnRecord.results[2].pineStructuredSummary.warningCountEstimate, 1);
+  assert.deepStrictEqual(turnRecord.results[2].pineStructuredSummary.statusSignals, ['compile-errors-visible', 'warnings-visible']);
+  assert.deepStrictEqual(turnRecord.results[2].pineStructuredSummary.topVisibleDiagnostics, [
+    'Compiler error at line 42: mismatched input.',
+    'Warning: script has unused variable.'
+  ]);
+});

scripts/test-pine-diagnostics-bounds.js

@@ -73,10 +73,28 @@ async function main() {
     assert(evidenceMessage.content.includes('latest visible revision label, latest visible relative time, visible revision count, and visible recency signal'));
     assert(evidenceMessage.content.includes('Do not infer hidden diffs, full script history, authorship, or runtime/chart behavior from the visible revision list alone.'));
   });
+
+  await test('pine line-budget prompt bounds visible count-hint inferences', async () => {
+    const evidenceMessage = await buildPineEvidenceMessage('open pine editor in tradingview and check the line budget');
+
+    assert(evidenceMessage, 'pine evidence block should be injected');
+    assert(evidenceMessage.content.includes('requestKind: line-budget'));
+    assert(evidenceMessage.content.includes('Treat visible line-count hints as bounded editor evidence'));
+    assert(evidenceMessage.content.includes('do not infer hidden script size beyond what the editor text shows'));
+  });
+
+  await test('pine generic-status prompt keeps status-only claims bounded', async () => {
+    const evidenceMessage = await buildPineEvidenceMessage('open pine editor in tradingview and show the visible status text');
+
+    assert(evidenceMessage, 'pine evidence block should be injected');
+    assert(evidenceMessage.content.includes('requestKind: generic-status'));
+    assert(evidenceMessage.content.includes('bounded editor evidence only'));
+    assert(evidenceMessage.content.includes('do not turn generic status text into runtime, chart, or market claims'));
+  });
 }
 
 main().catch((error) => {
   console.error('FAIL pine diagnostics bounds');
   console.error(error.stack || error.message);
   process.exit(1);
-});
+});

scripts/test-pine-editor-structured-summary.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+const assert = require('assert');
+const path = require('path');
+
+const systemAutomation = require(path.join(__dirname, '..', 'src', 'main', 'system-automation.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;
+  }
+}
+
+async function testAsync(name, fn) {
+  try {
+    await fn();
+    console.log(`PASS ${name}`);
+  } catch (error) {
+    console.error(`FAIL ${name}`);
+    console.error(error.stack || error.message);
+    process.exitCode = 1;
+  }
+}
+
+test('Pine compile-result summary stays bounded to visible compiler status', () => {
+  const summary = systemAutomation.buildPineEditorDiagnosticsStructuredSummary(
+    'Compiler: no errors. Status: strategy loaded.',
+    'compile-result'
+  );
+
+  assert(summary, 'summary should be returned');
+  assert.strictEqual(summary.evidenceMode, 'compile-result');
+  assert.strictEqual(summary.compileStatus, 'success');
+  assert.strictEqual(summary.errorCountEstimate, 0);
+  assert.strictEqual(summary.warningCountEstimate, 0);
+  assert(summary.statusSignals.includes('compile-success-visible'));
+  assert(summary.topVisibleDiagnostics.includes('Compiler: no errors. Status: strategy loaded.'));
+});
+
+test('Pine diagnostics summary surfaces visible compiler errors and warnings', () => {
+  const summary = systemAutomation.buildPineEditorDiagnosticsStructuredSummary(
+    'Compiler error at line 42: mismatched input. Warning: script has unused variable.',
+    'diagnostics'
+  );
+
+  assert(summary, 'summary should be returned');
+  assert.strictEqual(summary.evidenceMode, 'diagnostics');
+  assert.strictEqual(summary.compileStatus, 'errors-visible');
+  assert.strictEqual(summary.errorCountEstimate, 1);
+  assert.strictEqual(summary.warningCountEstimate, 1);
+  assert(summary.statusSignals.includes('compile-errors-visible'));
+  assert(summary.statusSignals.includes('warnings-visible'));
+  assert.deepStrictEqual(summary.topVisibleDiagnostics, [
+    'Compiler error at line 42: mismatched input. Warning: script has unused variable.'
+  ]);
+});
+
+test('Pine line-budget summary exposes visible count hints and limit pressure', () => {
+  const summary = systemAutomation.buildPineEditorDiagnosticsStructuredSummary(
+    'Line count: 487 / 500 lines. Warning: script is close to the Pine limit.',
+    'line-budget'
+  );
+
+  assert(summary, 'summary should be returned');
+  assert.strictEqual(summary.evidenceMode, 'line-budget');
+  assert.strictEqual(summary.visibleLineCountEstimate, 487);
+  assert.strictEqual(summary.lineBudgetSignal, 'near-limit-visible');
+  assert.strictEqual(summary.warningCountEstimate, 1);
+  assert(summary.statusSignals.includes('line-budget-hint-visible'));
+  assert(summary.statusSignals.includes('near-limit-visible'));
+});
+
+testAsync('GET_TEXT attaches Pine structured summary for compile-result mode', async () => {
+  const uiAutomation = require(path.join(__dirname, '..', 'src', 'main', 'ui-automation'));
+  const originalGetElementText = uiAutomation.getElementText;
+
+  uiAutomation.getElementText = async () => ({
+    success: true,
+    text: 'Compiler: no errors. Status: strategy loaded.',
+    method: 'TextPattern'
+  });
+
+  try {
+    const result = await systemAutomation.executeAction({
+      type: 'get_text',
+      text: 'Pine Editor',
+      pineEvidenceMode: 'compile-result'
+    });
+
+    assert.strictEqual(result.success, true);
+    assert.strictEqual(result.pineStructuredSummary.evidenceMode, 'compile-result');
+    assert.strictEqual(result.pineStructuredSummary.compileStatus, 'success');
+    assert(result.message.includes('status=success'));
+  } finally {
+    uiAutomation.getElementText = originalGetElementText;
+  }
+});

scripts/test-session-intent-state.js

@@ -411,3 +411,98 @@ test('session intent continuity recommends bounded new-script drafting for empty
 
   fs.rmSync(tempDir, { recursive: true, force: true });
 });
+
+test('session intent continuity surfaces Pine diagnostics state and recovery guidance', () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'liku-session-intent-'));
+  const stateFile = path.join(tempDir, 'session-intent-state.json');
+  const store = createSessionIntentStateStore({ stateFile });
+
+  const recorded = store.recordExecutedTurn({
+    userMessage: 'open pine editor in tradingview and check diagnostics',
+    executionIntent: 'Inspect visible Pine diagnostics.',
+    committedSubgoal: 'Inspect the visible Pine diagnostics state',
+    actionPlan: [
+      { type: 'focus_window', title: 'TradingView', processName: 'tradingview' },
+      { type: 'key', key: 'ctrl+e', verifyKind: 'panel-visible', verifyTarget: 'pine-editor' },
+      { type: 'get_text', text: 'Pine Editor' }
+    ],
+    results: [
+      { type: 'focus_window', success: true, message: 'focused' },
+      { type: 'key', success: true, message: 'editor opened' },
+      {
+        type: 'get_text',
+        success: true,
+        message: 'diagnostics inspected',
+        pineStructuredSummary: {
+          evidenceMode: 'diagnostics',
+          compileStatus: 'errors-visible',
+          errorCountEstimate: 1,
+          warningCountEstimate: 1,
+          lineBudgetSignal: 'unknown-line-budget',
+          statusSignals: ['compile-errors-visible', 'warnings-visible'],
+          topVisibleDiagnostics: ['Compiler error at line 42: mismatched input.', 'Warning: script has unused variable.'],
+          compactSummary: 'status=errors-visible | errors=1 | warnings=1'
+        }
+      }
+    ],
+    success: true,
+    verification: { status: 'verified' }
+  }, {
+    cwd: path.join(__dirname, '..')
+  });
+
+  assert(/fix the visible errors/i.test(recorded.chatContinuity.lastTurn.nextRecommendedStep));
+
+  const continuityContext = formatChatContinuityContext(recorded);
+  assert(continuityContext.includes('pineCompileStatus: errors-visible'));
+  assert(continuityContext.includes('pineErrorCountEstimate: 1'));
+  assert(continuityContext.includes('pineWarningCountEstimate: 1'));
+  assert(continuityContext.includes('pineTopVisibleDiagnostics: Compiler error at line 42: mismatched input. | Warning: script has unused variable.'));
+
+  fs.rmSync(tempDir, { recursive: true, force: true });
+});
+
+test('session intent continuity recommends targeted edits under Pine line-budget pressure', () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'liku-session-intent-'));
+  const stateFile = path.join(tempDir, 'session-intent-state.json');
+  const store = createSessionIntentStateStore({ stateFile });
+
+  const recorded = store.recordExecutedTurn({
+    userMessage: 'open pine editor in tradingview and check the line budget',
+    executionIntent: 'Inspect visible Pine line-budget hints.',
+    committedSubgoal: 'Inspect visible Pine line-budget hints',
+    actionPlan: [
+      { type: 'focus_window', title: 'TradingView', processName: 'tradingview' },
+      { type: 'key', key: 'ctrl+e', verifyKind: 'panel-visible', verifyTarget: 'pine-editor' },
+      { type: 'get_text', text: 'Pine Editor' }
+    ],
+    results: [
+      { type: 'focus_window', success: true, message: 'focused' },
+      { type: 'key', success: true, message: 'editor opened' },
+      {
+        type: 'get_text',
+        success: true,
+        message: 'line budget inspected',
+        pineStructuredSummary: {
+          evidenceMode: 'line-budget',
+          compileStatus: 'status-only',
+          errorCountEstimate: 0,
+          warningCountEstimate: 1,
+          visibleLineCountEstimate: 487,
+          lineBudgetSignal: 'near-limit-visible',
+          statusSignals: ['line-budget-hint-visible', 'near-limit-visible'],
+          topVisibleDiagnostics: ['Line count: 487 / 500 lines.', 'Warning: script is close to the Pine limit.'],
+          compactSummary: 'status=status-only | errors=0 | warnings=1 | lines=487 | budget=near-limit-visible'
+        }
+      }
+    ],
+    success: true,
+    verification: { status: 'verified' }
+  }, {
+    cwd: path.join(__dirname, '..')
+  });
+
+  assert(/targeted edits/i.test(recorded.chatContinuity.lastTurn.nextRecommendedStep));
+
+  fs.rmSync(tempDir, { recursive: true, force: true });
+});

src/main/ai-service/message-builder.js

@@ -97,6 +97,11 @@ function buildPineEvidenceConstraint({ foreground, userMessage }) {
 
   if (requestKind === 'line-budget') {
     lines.push('- Rule: Pine scripts are capped at 500 lines in TradingView. Treat visible line-count hints as bounded editor evidence, and prefer targeted edits over full rewrites when the budget is tight.');
+    lines.push('- Rule: Summarize only the visible line-count or budget hints; do not infer hidden script size beyond what the editor text shows.');
+  }
+
+  if (requestKind === 'generic-status') {
+    lines.push('- Rule: Treat visible Pine Editor status/output text as bounded editor evidence only; do not turn generic status text into runtime, chart, or market claims.');
   }
 
   if (requestKind === 'provenance-summary') {

src/main/chat-continuity-state.js

@@ -53,7 +53,13 @@ function normalizePineStructuredSummary(summary) {
     editorVisibleState: normalizeText(summary.editorVisibleState, 60),
     visibleScriptKind: normalizeText(summary.visibleScriptKind, 40),
     visibleLineCountEstimate: safeNumber(summary.visibleLineCountEstimate),
+    compileStatus: normalizeText(summary.compileStatus, 40),
+    errorCountEstimate: safeNumber(summary.errorCountEstimate),
+    warningCountEstimate: safeNumber(summary.warningCountEstimate),
+    lineBudgetSignal: normalizeText(summary.lineBudgetSignal, 60),
     visibleSignals: normalizeEvidenceList(summary.visibleSignals, 40),
+    statusSignals: normalizeEvidenceList(summary.statusSignals, 40),
+    topVisibleDiagnostics: normalizeEvidenceList(summary.topVisibleDiagnostics, 140),
     latestVisibleRevisionLabel: normalizeText(summary.latestVisibleRevisionLabel, 80),
     latestVisibleRevisionNumber: safeNumber(summary.latestVisibleRevisionNumber),
     latestVisibleRelativeTime: normalizeText(summary.latestVisibleRelativeTime, 80),
@@ -67,7 +73,13 @@ function normalizePineStructuredSummary(summary) {
     && !normalized.editorVisibleState
     && !normalized.visibleScriptKind
     && normalized.visibleLineCountEstimate === null
+    && !normalized.compileStatus
+    && normalized.errorCountEstimate === null
+    && normalized.warningCountEstimate === null
+    && !normalized.lineBudgetSignal
     && normalized.visibleSignals.length === 0
+    && normalized.statusSignals.length === 0
+    && normalized.topVisibleDiagnostics.length === 0
     && !normalized.latestVisibleRevisionLabel
     && normalized.latestVisibleRevisionNumber === null
     && !normalized.latestVisibleRelativeTime