Track D: structure Pine revision metadata summaries

Author: TayDa64

docs/CHAT_CONTINUITY_IMPLEMENTATION_PLAN.md

@@ -1674,6 +1674,17 @@ This is the next Pine-facing implementation slice after the current Logs / Profi
 
 #### Slice D-next-2 — Pine Version History top visible revision metadata summaries
 
+**Status:** First slice completed in working tree
+
+**Delivered so far**
+- extended `src/main/tradingview/pine-workflows.js` with a `provenance-summary` evidence mode for `pine-version-history`
+- Version History metadata requests such as `summarize the top visible revision metadata` now preserve or auto-append bounded `get_text` provenance-summary readback
+- extended prompt/seam/execution coverage in:
+  - `src/main/ai-service/message-builder.js`
+  - `scripts/test-tradingview-pine-data-workflows.js`
+  - `scripts/test-windows-observation-flow.js`
+  - `scripts/test-bug-fixes.js`
+
 **Why this is second**
 - the UI access path is already implemented, but the current behavior is still just raw visible text gathering
 - the next value is structural summarization of the top visible revisions, not merely reopening the panel

scripts/test-bug-fixes.js

@@ -249,6 +249,8 @@ test('pine workflow encodes diagnostics and compile-result evidence modes', () =
   assert(pineWorkflowContent.includes('pineEvidenceMode'), 'Pine get_text steps should preserve evidence mode metadata');
   assert(pineWorkflowContent.includes('compile-result text for a bounded diagnostics summary'), 'Pine workflows should use compile-result-specific readback wording');
   assert(pineWorkflowContent.includes('diagnostics and warnings text'), 'Pine workflows should use diagnostics-specific readback wording');
+  assert(pineWorkflowContent.includes('provenance-summary'), 'Pine workflows should support version-history provenance-summary evidence mode');
+  assert(pineWorkflowContent.includes('top visible Pine Version History revision metadata'), 'Pine workflows should use provenance-summary-specific readback wording');
 });
 
 test('system prompt includes Pine diagnostics guidance', () => {
@@ -258,6 +260,8 @@ test('system prompt includes Pine diagnostics guidance', () => {
   const systemPromptContent = fs.readFileSync(systemPromptPath, 'utf8');
 
   assert(systemPromptContent.includes('TradingView Pine diagnostics rule'), 'System prompt should include Pine diagnostics guidance');
+  assert(systemPromptContent.includes('visible revision/provenance details'), 'System prompt should steer Pine provenance requests toward verified Version History text');
+  assert(systemPromptContent.includes('treat visible Pine Version History entries as bounded audit/provenance evidence only'), 'Pine provenance guidance should prevent overclaiming from visible revision history');
   assert(systemPromptContent.includes('compile success'), 'System prompt should mention compile success bounds');
   assert(systemPromptContent.includes('realtime rollback'), 'System prompt should mention Pine execution-model caveats');
 });

scripts/test-pine-diagnostics-bounds.js

@@ -63,6 +63,15 @@ async function main() {
     assert(evidenceMessage.content.includes('Rule: Surface visible compiler errors and warnings as bounded diagnostics evidence; do not infer hidden causes or chart-state effects unless the visible text states them.'));
     assert(evidenceMessage.content.includes('mention Pine execution-model caveats such as realtime rollback, confirmed vs unconfirmed bars, and indicator vs strategy recalculation differences'));
   });
+
+  await test('pine provenance prompt bounds visible revision metadata inferences', async () => {
+    const evidenceMessage = await buildPineEvidenceMessage('open pine version history in tradingview and summarize the top visible revision metadata');
+
+    assert(evidenceMessage, 'pine evidence block should be injected');
+    assert(evidenceMessage.content.includes('requestKind: provenance-summary'));
+    assert(evidenceMessage.content.includes('Treat Pine Version History as bounded provenance evidence only'));
+    assert(evidenceMessage.content.includes('Do not infer hidden diffs, full script history, authorship, or runtime/chart behavior from the visible revision list alone.'));
+  });
 }
 
 main().catch((error) => {

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

@@ -6,7 +6,8 @@ const path = require('path');
 const {
   inferTradingViewPineIntent,
   buildTradingViewPineWorkflowActions,
-  maybeRewriteTradingViewPineWorkflow
+  maybeRewriteTradingViewPineWorkflow,
+  inferPineVersionHistoryEvidenceMode
 } = require(path.join(__dirname, '..', 'src', 'main', 'tradingview', 'pine-workflows.js'));
 
 function test(name, fn) {
@@ -92,6 +93,23 @@ test('pine workflow recognizes pine version history provenance requests', () =>
   assert.strictEqual(intent.wantsEvidenceReadback, true);
 });
 
+test('pine workflow classifies version history metadata summary requests', () => {
+  const mode = inferPineVersionHistoryEvidenceMode('open pine version history in tradingview and summarize the top visible revision metadata');
+
+  assert.strictEqual(mode, 'provenance-summary');
+});
+
+test('pine workflow recognizes visible revision metadata requests', () => {
+  const intent = inferTradingViewPineIntent('open pine version history in tradingview and summarize the top visible revision metadata', [
+    { type: 'key', key: 'alt+h' }
+  ]);
+
+  assert(intent, 'intent should be inferred');
+  assert.strictEqual(intent.surfaceTarget, 'pine-version-history');
+  assert.strictEqual(intent.wantsEvidenceReadback, true);
+  assert.strictEqual(intent.pineEvidenceMode, 'provenance-summary');
+});
+
 test('open pine logs and read output stays verification-first', () => {
   const rewritten = buildTradingViewPineWorkflowActions({
     appName: 'TradingView',
@@ -228,6 +246,25 @@ test('open pine version history and read revisions stays verification-first', ()
   assert.strictEqual(rewritten[4].text, 'Pine Version History');
 });
 
+test('open pine version history and summarize visible revision metadata stays verification-first', () => {
+  const rewritten = buildTradingViewPineWorkflowActions({
+    appName: 'TradingView',
+    surfaceTarget: 'pine-version-history',
+    verifyKind: 'panel-visible',
+    openerIndex: 0,
+    wantsEvidenceReadback: true,
+    pineEvidenceMode: 'provenance-summary',
+    requiresObservedChange: false
+  }, [
+    { type: 'key', key: 'alt+h', reason: 'Open Pine Version History' }
+  ]);
+
+  assert.strictEqual(rewritten[4].type, 'get_text');
+  assert.strictEqual(rewritten[4].text, 'Pine Version History');
+  assert.strictEqual(rewritten[4].pineEvidenceMode, 'provenance-summary');
+  assert(/top visible Pine Version History revision metadata/i.test(rewritten[4].reason), 'version-history metadata readback should use provenance-summary wording');
+});
+
 test('pine evidence-gathering workflow preserves trailing get_text read step', () => {
   const rewritten = maybeRewriteTradingViewPineWorkflow([
     { type: 'key', key: 'ctrl+shift+l' },
@@ -288,6 +325,22 @@ test('pine version history workflow preserves trailing get_text read step', () =
   assert.strictEqual(rewritten[2].verify.target, 'pine-version-history');
 });
 
+test('pine version history metadata workflow preserves trailing get_text read step', () => {
+  const rewritten = maybeRewriteTradingViewPineWorkflow([
+    { type: 'key', key: 'alt+h' },
+    { type: 'get_text', text: 'Pine Version History', reason: 'Read top visible Pine Version History revision metadata', pineEvidenceMode: 'provenance-summary' }
+  ], {
+    userMessage: 'open pine version history in tradingview and summarize the top visible revision metadata'
+  });
+
+  assert(Array.isArray(rewritten), 'workflow should rewrite');
+  const readSteps = rewritten.filter((action) => action?.type === 'get_text');
+  assert.strictEqual(readSteps.length, 1, 'explicit version-history metadata readback step should be preserved without duplication');
+  assert.strictEqual(readSteps[0].text, 'Pine Version History');
+  assert.strictEqual(readSteps[0].pineEvidenceMode, 'provenance-summary');
+  assert.strictEqual(rewritten[2].verify.target, 'pine-version-history');
+});
+
 test('pine workflow does not hijack speculative chart-analysis prompts', () => {
   const rewritten = maybeRewriteTradingViewPineWorkflow([
     { type: 'screenshot' }

scripts/test-windows-observation-flow.js

@@ -358,6 +358,20 @@ async function run() {
     assert.strictEqual(rewritten[4].text, 'Pine Version History');
   });
 
+  await testAsync('low-signal TradingView Pine Version History metadata request rewrites to provenance-summary get_text', async () => {
+    const rewritten = aiService.rewriteActionsForReliability([
+      { type: 'key', key: 'alt+h' }
+    ], {
+      userMessage: 'open pine version history in tradingview and summarize the top visible revision metadata'
+    });
+
+    assert(Array.isArray(rewritten), 'pine version history metadata rewrite should return an action array');
+    assert.strictEqual(rewritten[2].verify.target, 'pine-version-history');
+    assert.strictEqual(rewritten[4].type, 'get_text');
+    assert.strictEqual(rewritten[4].text, 'Pine Version History');
+    assert.strictEqual(rewritten[4].pineEvidenceMode, 'provenance-summary');
+  });
+
   await testAsync('verified pine logs workflow allows bounded evidence gathering without screenshot loop', async () => {
     const executed = [];
     const foregroundSequence = [
@@ -514,6 +528,60 @@ async function run() {
     });
   });
 
+  await testAsync('verified pine version history metadata workflow preserves top visible revision text without screenshot loop', async () => {
+    const executed = [];
+    const evidenceModes = [];
+    const foregroundSequence = [
+      { success: true, hwnd: 777, title: 'TradingView', processName: 'tradingview', windowKind: 'main' },
+      { success: true, hwnd: 891, title: 'Pine Version History - TradingView', processName: 'tradingview', windowKind: 'owned' },
+      { success: true, hwnd: 891, title: 'Pine Version History - TradingView', processName: 'tradingview', windowKind: 'owned' },
+      { success: true, hwnd: 891, title: 'Pine Version History - TradingView', processName: 'tradingview', windowKind: 'owned' }
+    ];
+
+    await withPatchedSystemAutomation({
+      resolveWindowHandle: async (action) => action?.processName === 'tradingview' ? 777 : 0,
+      getForegroundWindowHandle: async () => 777,
+      getForegroundWindowInfo: async () => {
+        return foregroundSequence.shift() || { success: true, hwnd: 891, title: 'Pine Version History - TradingView', processName: 'tradingview', windowKind: 'owned' };
+      },
+      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 Pine Version History and summarize the top visible revision metadata',
+        verification: 'TradingView should show Pine Version History before text is read',
+        actions: [
+          { type: 'focus_window', title: 'TradingView', processName: 'tradingview' },
+          { type: 'key', key: 'alt+h', reason: 'Open Pine Version History', verify: { kind: 'panel-visible', appName: 'TradingView', target: 'pine-version-history', keywords: ['pine version history', 'version history', 'pine'] } },
+          { type: 'get_text', text: 'Pine Version History', reason: 'Read top visible Pine Version History revision metadata', pineEvidenceMode: 'provenance-summary' }
+        ]
+      }, null, null, {
+        userMessage: 'open pine version history in tradingview and summarize the top visible revision metadata',
+        actionExecutor: async (action) => {
+          executed.push(action.type);
+          if (action.type === 'get_text') {
+            evidenceModes.push(action.pineEvidenceMode || null);
+            return {
+              success: true,
+              action: action.type,
+              text: 'Revision 18 saved 2m ago; Revision 17 saved 18m ago; showing 2 visible revisions',
+              method: 'TextPattern',
+              message: 'Got text via TextPattern: "Revision 18 saved 2m ago; Revision 17 saved 18m ago; showing 2 visible revisions"'
+            };
+          }
+          return { success: true, action: action.type, message: 'executed' };
+        }
+      });
+
+      assert.strictEqual(execResult.success, true, 'Execution should proceed after Pine Version History metadata view is observed');
+      assert.deepStrictEqual(executed, ['focus_window', 'key', 'get_text'], 'Version History metadata summary should continue to read text after panel verification');
+      assert.deepStrictEqual(evidenceModes, ['provenance-summary'], 'Version History metadata workflow should preserve provenance-summary evidence mode');
+      assert.strictEqual(execResult.observationCheckpoints[0].verified, true, 'Pine Version History panel observation should pass');
+      assert.strictEqual(execResult.results[2].text, 'Revision 18 saved 2m ago; Revision 17 saved 18m ago; showing 2 visible revisions', 'Version History metadata text should be preserved on the get_text result');
+      assert(!execResult.screenshotCaptured, 'Pine Version History metadata gathering should not require a screenshot loop');
+    });
+  });
+
   await testAsync('verified pine editor diagnostics workflow gathers compile text without screenshot loop', async () => {
     const executed = [];
     const evidenceModes = [];

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

@@ -46,6 +46,11 @@ function inferPineEvidenceRequestKind(userMessage = '') {
     return 'generic-status';
   }
 
+  if (/\b(version history|revision|revisions|provenance|history|versions)\b/.test(text)
+    && /\b(latest|top|visible|recent|metadata|summary|summarize|details)\b/.test(text)) {
+    return 'provenance-summary';
+  }
+
   return null;
 }
 
@@ -78,6 +83,11 @@ function buildPineEvidenceConstraint({ foreground, userMessage }) {
     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.');
   }
 
+  if (requestKind === 'provenance-summary') {
+    lines.push('- Rule: Treat Pine Version History as bounded provenance evidence only; summarize only the top visible revision labels, relative times, and other metadata that are directly visible.');
+    lines.push('- Rule: Do not infer hidden diffs, full script history, authorship, or runtime/chart behavior from the visible revision list alone.');
+  }
+
   lines.push('- Rule: If the user asks for Pine runtime or strategy diagnosis, mention Pine execution-model caveats such as realtime rollback, confirmed vs unconfirmed bars, and indicator vs strategy recalculation differences before inferring behavior from compile status alone.');
   return lines.join('\n');
 }

src/main/ai-service/system-prompt.js

@@ -229,6 +229,7 @@ When the user asks you to DO something, respond with a JSON action block:
 - **Continuity rule**: if the active page title or recent action output indicates the requested browser objective is already achieved, acknowledge completion and avoid proposing additional screenshot steps.
 - **TradingView Pine evidence rule**: if the user wants concrete Pine output, errors, profiler-style evidence, visible Pine Editor status/output, or visible revision/provenance details, prefer \`open/show Pine Editor, Logs, Profiler, or Version History\` + verified panel opening + \`get_text\` before relying on screenshot analysis.
 - **TradingView Pine diagnostics rule**: treat visible Pine Editor compile results, compiler errors, warnings, and diagnostics as bounded text evidence. Do not turn \`no errors\` into claims about runtime correctness, market validity, or trading edge.
+- **TradingView Pine provenance rule**: treat visible Pine Version History entries as bounded audit/provenance evidence only. Summarize top visible revision labels, relative times, and other directly visible metadata, but do not infer hidden diffs, full script history, authorship, or runtime/chart behavior from the visible list alone.
 - **TradingView Pine line-budget rule**: Pine scripts are limited to 500 lines. Do not propose pasting or generating Pine scripts longer than 500 lines; prefer bounded edits, read visible line/status hints first when needed, and mention the limit explicitly when it affects read/write guidance.
 - **If you need to interact with web content inside an app** (like VS Code panels, browser tabs): Use keyboard shortcuts or coordinate-based clicks since web UI may not appear in UIA tree
 

src/main/tradingview/pine-workflows.js

@@ -62,6 +62,17 @@ function inferPineEditorEvidenceMode(raw = '') {
   return 'generic-status';
 }
 
+function inferPineVersionHistoryEvidenceMode(raw = '') {
+  const normalized = normalizeTextForMatch(raw);
+  if (!normalized) return 'generic-provenance';
+
+  const mentionsMetadataSummary = /\b(latest|top|visible|recent|newest|metadata|summary|summarize|revision metadata|provenance details|revision details)\b/.test(normalized);
+  const mentionsRevisionList = /\b(revision|revisions|version history|history|versions|changes|provenance)\b/.test(normalized);
+  if (mentionsRevisionList && mentionsMetadataSummary) return 'provenance-summary';
+
+  return 'generic-provenance';
+}
+
 function buildPineReadbackStep(surfaceTarget, evidenceMode = null) {
   if (surfaceTarget === 'pine-editor') {
     const mode = evidenceMode || 'generic-status';
@@ -97,10 +108,14 @@ function buildPineReadbackStep(surfaceTarget, evidenceMode = null) {
   }
 
   if (surfaceTarget === 'pine-version-history') {
+    const mode = evidenceMode || 'generic-provenance';
     return {
       type: 'get_text',
       text: 'Pine Version History',
-      reason: 'Read visible Pine Version History entries for bounded provenance gathering'
+      reason: mode === 'provenance-summary'
+        ? 'Read top visible Pine Version History revision metadata for a bounded provenance summary'
+        : 'Read visible Pine Version History entries for bounded provenance gathering',
+      pineEvidenceMode: mode
     };
   }
 
@@ -156,6 +171,8 @@ function inferTradingViewPineIntent(userMessage = '', actions = []) {
   const wantsEvidenceReadback = inferPineEvidenceReadIntent(raw, surface.target);
   const pineEvidenceMode = surface.target === 'pine-editor' && wantsEvidenceReadback
     ? inferPineEditorEvidenceMode(raw)
+    : surface.target === 'pine-version-history' && wantsEvidenceReadback
+      ? inferPineVersionHistoryEvidenceMode(raw)
     : null;
 
   const existingWorkflowSignal = Array.isArray(actions) && actions.some((action) => /pine/.test(String(action?.verify?.target || '')));
@@ -262,5 +279,6 @@ function maybeRewriteTradingViewPineWorkflow(actions, context = {}) {
 module.exports = {
   inferTradingViewPineIntent,
   buildTradingViewPineWorkflowActions,
-  maybeRewriteTradingViewPineWorkflow
+  maybeRewriteTradingViewPineWorkflow,
+  inferPineVersionHistoryEvidenceMode
 };