Prove chat continuity and extract TradingView helpers

Author: TayDa64

docs/CHAT_CONTINUITY_IMPLEMENTATION_PLAN.md

@@ -228,34 +228,40 @@ test('rewriteActionsForReliability normalizes typoed app launches', () => {
 
 test('ai-service normalizes app identity for learned skill scope', () => {
   const aiServicePath = path.join(__dirname, '..', 'src', 'main', 'ai-service.js');
+  const appProfilePath = path.join(__dirname, '..', 'src', 'main', 'tradingview', 'app-profile.js');
   const fs = require('fs');
 
   const aiServiceContent = fs.readFileSync(aiServicePath, 'utf8');
+  const appProfileContent = fs.readFileSync(appProfilePath, 'utf8');
 
-  assert(aiServiceContent.includes('resolveNormalizedAppIdentity('), 'ai-service should define normalized app identity resolution');
-  assert(aiServiceContent.includes("'tradeing view'"), 'ai-service should recognize the TradingView typo alias');
+  assert(aiServiceContent.includes("require('./tradingview/app-profile')"), 'ai-service should consume the extracted app profile module');
+  assert(appProfileContent.includes('resolveNormalizedAppIdentity('), 'app profile module should define normalized app identity resolution');
+  assert(appProfileContent.includes("'tradeing view'"), 'app profile module should recognize the TradingView typo alias');
   assert(aiServiceContent.includes('normalizedSkillApp?.processNames'), 'Learned skill scope should include normalized process names');
   assert(aiServiceContent.includes('normalizedSkillApp?.titleHints'), 'Learned skill scope should include normalized title hints');
-  assert(aiServiceContent.includes('dialogTitleHints'), 'TradingView app profile should include dialog title hints');
-  assert(aiServiceContent.includes('chartKeywords'), 'TradingView app profile should include chart-state keywords');
-  assert(aiServiceContent.includes('drawingKeywords'), 'TradingView app profile should include drawing-tool keywords');
-  assert(aiServiceContent.includes('pineKeywords'), 'TradingView app profile should include Pine Editor keywords');
-  assert(aiServiceContent.includes('domKeywords'), 'TradingView app profile should include DOM keywords');
+  assert(appProfileContent.includes('dialogTitleHints'), 'TradingView app profile should include dialog title hints');
+  assert(appProfileContent.includes('chartKeywords'), 'TradingView app profile should include chart-state keywords');
+  assert(appProfileContent.includes('drawingKeywords'), 'TradingView app profile should include drawing-tool keywords');
+  assert(appProfileContent.includes('pineKeywords'), 'TradingView app profile should include Pine Editor keywords');
+  assert(appProfileContent.includes('domKeywords'), 'TradingView app profile should include DOM keywords');
 });
 
 test('ai-service gates TradingView follow-up typing on post-key observation checkpoints', () => {
   const aiServicePath = path.join(__dirname, '..', 'src', 'main', 'ai-service.js');
+  const tradingViewVerificationPath = path.join(__dirname, '..', 'src', 'main', 'tradingview', 'verification.js');
   const fs = require('fs');
 
   const aiServiceContent = fs.readFileSync(aiServicePath, 'utf8');
+  const tradingViewVerificationContent = fs.readFileSync(tradingViewVerificationPath, 'utf8');
 
   assert(aiServiceContent.includes('inferKeyObservationCheckpoint'), 'ai-service should infer TradingView post-key checkpoints');
   assert(aiServiceContent.includes('verifyKeyObservationCheckpoint'), 'ai-service should verify TradingView post-key checkpoints');
   assert(aiServiceContent.includes('observationCheckpoints'), 'Execution results should expose key checkpoint metadata');
   assert(aiServiceContent.includes('surface change before continuing'), 'Checkpoint failures should explain missing TradingView surface changes');
-  assert(aiServiceContent.includes("classification === 'panel-open'"), 'TradingView checkpoints should recognize panel-open flows such as Pine or DOM');
-  assert(aiServiceContent.includes('pine editor'), 'TradingView checkpoints should ground Pine Editor workflows');
-  assert(aiServiceContent.includes('depth of market'), 'TradingView checkpoints should ground DOM workflows');
+  assert(aiServiceContent.includes('inferTradingViewObservationSpec'), 'ai-service should consume the extracted TradingView observation-spec 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');
 });
 
 test('ai-service treats TradingView DOM order-entry actions as high risk', () => {

scripts/test-bug-fixes.js

@@ -11,6 +11,53 @@ const originalLoad = Module._load;
 
 let executeCount = 0;
 let seenMessages = [];
+let continuityState = process.env.__CHAT_CONTINUITY__ ? JSON.parse(process.env.__CHAT_CONTINUITY__) : null;
+const scriptedVisualStates = process.env.__LATEST_VISUAL_SEQUENCE__ ? JSON.parse(process.env.__LATEST_VISUAL_SEQUENCE__) : [];
+let lastRecordedTurn = null;
+
+function isScreenLikeCaptureMode(captureMode) {
+  const normalized = String(captureMode || '').trim().toLowerCase();
+  return normalized === 'screen'
+    || normalized === 'fullscreen-fallback'
+    || normalized.startsWith('screen-')
+    || normalized.includes('fullscreen');
+}
+
+function deriveContinuityState(turnRecord) {
+  const actionSummary = Array.isArray(turnRecord?.actionPlan)
+    ? turnRecord.actionPlan.map((action) => action?.type).filter(Boolean).join(' -> ')
+    : null;
+  const verificationStatus = String(turnRecord?.verification?.status || '').trim() || null;
+  const captureMode = String(turnRecord?.observationEvidence?.captureMode || '').trim() || null;
+  const captureTrusted = typeof turnRecord?.observationEvidence?.captureTrusted === 'boolean'
+    ? turnRecord.observationEvidence.captureTrusted
+    : null;
+
+  let degradedReason = null;
+  if (turnRecord?.cancelled || turnRecord?.executionResult?.cancelled) {
+    degradedReason = 'The last action batch was cancelled before completion.';
+  } else if (verificationStatus === 'contradicted') {
+    degradedReason = 'The latest evidence contradicts the claimed result.';
+  } else if (verificationStatus === 'unverified') {
+    degradedReason = 'The latest result is not fully verified yet.';
+  } else if (isScreenLikeCaptureMode(captureMode) && captureTrusted === false) {
+    degradedReason = 'Visual evidence fell back to full-screen capture instead of a trusted target-window capture.';
+  }
+
+  return {
+    activeGoal: turnRecord?.activeGoal || turnRecord?.executionIntent || turnRecord?.userMessage || null,
+    currentSubgoal: turnRecord?.currentSubgoal || turnRecord?.committedSubgoal || turnRecord?.thought || null,
+    continuationReady: !degradedReason && !(turnRecord?.cancelled || turnRecord?.executionResult?.cancelled) && turnRecord?.executionStatus !== 'failed',
+    degradedReason,
+    lastTurn: {
+      actionSummary,
+      nextRecommendedStep: turnRecord?.nextRecommendedStep || null,
+      verificationStatus,
+      captureMode,
+      captureTrusted
+    }
+  };
+}
 
 const actionResponse = JSON.stringify({
   thought: 'Set alert in TradingView',
@@ -39,6 +86,10 @@ const aiStub = {
     executeCount++;
     return { success: true, results: [], screenshotCaptured: false, postVerification: { verified: true } };
   },
+  getLatestVisualContext: () => {
+    if (!Array.isArray(scriptedVisualStates) || scriptedVisualStates.length === 0) return null;
+    return scriptedVisualStates[Math.max(0, executeCount - 1)] || scriptedVisualStates[scriptedVisualStates.length - 1] || null;
+  },
   parsePreferenceCorrection: async () => ({ success: false, error: 'not needed' })
 };
 
@@ -59,18 +110,31 @@ const preferencesStub = {
   mergeAppPolicy: () => ({ success: true })
 };
 
+const sessionIntentStateStub = {
+  getChatContinuityState: () => continuityState,
+  recordChatContinuityTurn: (turnRecord) => {
+    lastRecordedTurn = turnRecord;
+    continuityState = deriveContinuityState(turnRecord);
+    return continuityState;
+  }
+};
+
 Module._load = function(request, parent, isMain) {
   if (request === '../../main/ai-service') return aiStub;
   if (request === '../../main/ui-watcher') return watcherStub;
   if (request === '../../main/system-automation') return systemAutomationStub;
   if (request === '../../main/preferences') return preferencesStub;
+  if (request === '../../main/session-intent-state') return sessionIntentStateStub;
   return originalLoad.apply(this, arguments);
 };
 
 (async () => {
   const chat = require('${chatModulePath}');
   const result = await chat.run([], { execute: 'auto', quiet: true });
   console.log('EXECUTE_COUNT:' + executeCount);
+  console.log('SEEN_MESSAGES:' + JSON.stringify(seenMessages));
+  console.log('RECORDED_CONTINUITY:' + JSON.stringify(continuityState));
+  console.log('LAST_TURN:' + JSON.stringify(lastRecordedTurn));
   process.exit(result && result.success === false ? 1 : 0);
 })().catch((error) => {
   console.error(error.stack || error.message);
@@ -79,12 +143,20 @@ Module._load = function(request, parent, isMain) {
 }
 
 async function runScenario(inputs) {
+  return runScenarioWithContinuity(inputs, null, null);
+}
+
+async function runScenarioWithContinuity(inputs, continuityState, latestVisualSequence) {
   const repoRoot = path.join(__dirname, '..');
   const chatModulePath = path.join(repoRoot, 'src', 'cli', 'commands', 'chat.js').replace(/\\/g, '\\\\');
   const child = spawn(process.execPath, ['-e', buildHarnessScript(chatModulePath)], {
     cwd: repoRoot,
     stdio: ['pipe', 'pipe', 'pipe'],
-    env: process.env
+    env: {
+      ...process.env,
+      __CHAT_CONTINUITY__: continuityState ? JSON.stringify(continuityState) : '',
+      __LATEST_VISUAL_SEQUENCE__: latestVisualSequence ? JSON.stringify(latestVisualSequence) : ''
+    }
   });
 
   let output = '';
@@ -123,6 +195,81 @@ async function main() {
   assert(continuity.output.includes('EXECUTE_COUNT:1'), 'continuity-style scenario should execute the emitted actions once');
   assert(!continuity.output.includes('Parsed action plan withheld'), 'continuity-style scenario should not be withheld as non-executable text');
 
+  const stateBackedContinuation = await runScenarioWithContinuity(['continue'], {
+    activeGoal: 'Produce a confident synthesis of ticker LUNR in TradingView',
+    currentSubgoal: 'Inspect the active TradingView chart',
+    continuationReady: true,
+    degradedReason: null,
+    lastTurn: {
+      actionSummary: 'focus_window -> screenshot',
+      nextRecommendedStep: 'Continue from the latest chart evidence.'
+    }
+  });
+  assert.strictEqual(stateBackedContinuation.exitCode, 0, 'state-backed continuation scenario should exit successfully');
+  assert(stateBackedContinuation.output.includes('EXECUTE_COUNT:1'), 'state-backed continuation should execute emitted actions');
+  assert(stateBackedContinuation.output.includes('SEEN_MESSAGES:["continue"]'), 'state-backed continuation should still send the minimal prompt while execution routing relies on saved continuity');
+
+  const persistedContinuation = await runScenarioWithContinuity([
+    'help me make a confident synthesis of ticker LUNR in tradingview',
+    'continue'
+  ], null, [{
+    captureMode: 'window-copyfromscreen',
+    captureTrusted: true,
+    timestamp: 111,
+    windowHandle: 458868,
+    windowTitle: 'TradingView - LUNR'
+  }]);
+  assert.strictEqual(persistedContinuation.exitCode, 0, 'persisted continuation scenario should exit successfully');
+  assert(persistedContinuation.output.includes('EXECUTE_COUNT:2'), 'persisted continuation should execute both the original and follow-up turn');
+  assert(persistedContinuation.output.includes('SEEN_MESSAGES:["help me make a confident synthesis of ticker LUNR in tradingview","continue"]'), 'persisted continuation should keep the second user turn minimal while relying on recorded state');
+  assert(/RECORDED_CONTINUITY:.*"continuationReady":true/i.test(persistedContinuation.output), 'persisted continuation should record usable continuity between turns');
+
+  const persistedDegradedContinuation = await runScenarioWithContinuity([
+    'help me make a confident synthesis of ticker LUNR in tradingview',
+    'continue'
+  ], null, [{
+    captureMode: 'screen-copyfromscreen',
+    captureTrusted: false,
+    timestamp: 222,
+    windowTitle: 'Desktop'
+  }]);
+  assert.strictEqual(persistedDegradedContinuation.exitCode, 0, 'persisted degraded continuation should exit successfully');
+  assert(persistedDegradedContinuation.output.includes('EXECUTE_COUNT:1'), 'persisted degraded continuation should block the second execution');
+  assert(/Continuity is currently degraded/i.test(persistedDegradedContinuation.output), 'persisted degraded continuation should explain degraded recovery requirements');
+  assert(/RECORDED_CONTINUITY:.*"continuationReady":false/i.test(persistedDegradedContinuation.output), 'persisted degraded continuation should record degraded continuity after the first turn');
+
+  const degradedContinuation = await runScenarioWithContinuity(['continue'], {
+    activeGoal: 'Produce a confident synthesis of ticker LUNR in TradingView',
+    currentSubgoal: 'Inspect the active TradingView chart',
+    continuationReady: false,
+    degradedReason: 'Visual evidence fell back to full-screen capture instead of a trusted target-window capture.',
+    lastTurn: {
+      verificationStatus: 'verified',
+      captureMode: 'screen-copyfromscreen',
+      captureTrusted: false,
+      nextRecommendedStep: 'Continue from the latest chart evidence.'
+    }
+  });
+  assert.strictEqual(degradedContinuation.exitCode, 0, 'degraded continuation scenario should exit successfully');
+  assert(degradedContinuation.output.includes('EXECUTE_COUNT:0'), 'degraded continuation should not execute emitted actions');
+  assert(/Continuity is currently degraded/i.test(degradedContinuation.output), 'degraded continuation should explain recovery-oriented continuity blocking');
+
+  const contradictedContinuation = await runScenarioWithContinuity(['continue'], {
+    activeGoal: 'Add a TradingView indicator and verify it on chart',
+    currentSubgoal: 'Verify the indicator is present',
+    continuationReady: false,
+    degradedReason: 'The latest evidence contradicts the claimed result.',
+    lastTurn: {
+      verificationStatus: 'contradicted',
+      captureMode: 'window-copyfromscreen',
+      captureTrusted: true,
+      nextRecommendedStep: 'Retry indicator search before claiming success.'
+    }
+  });
+  assert.strictEqual(contradictedContinuation.exitCode, 0, 'contradicted continuation scenario should exit successfully');
+  assert(contradictedContinuation.output.includes('EXECUTE_COUNT:0'), 'contradicted continuation should not execute emitted actions');
+  assert(/contradicted by the latest evidence/i.test(contradictedContinuation.output), 'contradicted continuation should explain why blind continuation is blocked');
+
   const acknowledgement = await runScenario(['thanks']);
   assert.strictEqual(acknowledgement.exitCode, 0, 'acknowledgement-style scenario should exit successfully');
   assert(acknowledgement.output.includes('EXECUTE_COUNT:0'), 'acknowledgement-style scenario should not execute emitted actions');