cdp-skill 1.0.7 → 1.0.14

package/src/tests/ExecuteDynamic.test.js

@@ -7,13 +7,8 @@ import os from 'os';
 import {
   executePageFunction,
   executePoll,
-  compilePipeline,
-  executePipeline,
-  executeWriteSiteManifest,
-  loadSiteManifest,
-  generateLightManifest,
-  runLightAutoFit,
-  LIGHT_FIT_SCRIPT
+  executeWriteSiteProfile,
+  loadSiteProfile
 } from '../runner/execute-dynamic.js';
 
 import { validateStepInternal, validateSteps } from '../runner/step-validator.js';
@@ -50,11 +45,11 @@ function createMockPageController(evalReturnValue, opts = {}) {
   };
 }
 
-// Patch SITES_DIR for manifest tests by overriding environment
+// Patch SITES_DIR for profile tests by overriding environment
 // We use a temp directory to avoid polluting ~/.cdp-skill/sites/
 const REAL_SITES_DIR = path.join(os.homedir(), '.cdp-skill', 'sites');
 
-async function cleanupTestManifests(domains) {
+async function cleanupTestProfiles(domains) {
   for (const domain of domains) {
     const clean = domain.replace(/^www\./, '').replace(/[^a-zA-Z0-9.\-]/g, '_');
     try {
@@ -288,699 +283,30 @@ describe('executePoll', () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// Tests: compilePipeline
-// ---------------------------------------------------------------------------
-
-describe('compilePipeline', () => {
-  it('should generate valid JS for find+fill', () => {
-    const js = compilePipeline([{ find: '#name', fill: 'John' }]);
-    assert.ok(js.includes('document.querySelector'));
-    assert.ok(js.includes('#name'));
-    assert.ok(js.includes('John'));
-    assert.ok(js.includes('nativeSetter'));
-    assert.ok(js.includes("dispatchEvent(new Event('input'"));
-  });
-
-  it('should generate valid JS for find+click', () => {
-    const js = compilePipeline([{ find: '#btn', click: true }]);
-    assert.ok(js.includes('document.querySelector'));
-    assert.ok(js.includes('#btn'));
-    assert.ok(js.includes('.click()'));
-  });
-
-  it('should generate valid JS for find+type', () => {
-    const js = compilePipeline([{ find: '#search', type: 'hello' }]);
-    assert.ok(js.includes('document.querySelector'));
-    assert.ok(js.includes('#search'));
-    assert.ok(js.includes('focus'));
-    assert.ok(js.includes('KeyboardEvent'));
-    assert.ok(js.includes('hello'));
-  });
-
-  it('should generate valid JS for find+check', () => {
-    const js = compilePipeline([{ find: '#agree', check: true }]);
-    assert.ok(js.includes('document.querySelector'));
-    assert.ok(js.includes('#agree'));
-    assert.ok(js.includes('checked'));
-    assert.ok(js.includes('true'));
-  });
-
-  it('should generate valid JS for find+select', () => {
-    const js = compilePipeline([{ find: '#color', select: 'red' }]);
-    assert.ok(js.includes('document.querySelector'));
-    assert.ok(js.includes('#color'));
-    assert.ok(js.includes('"red"'));
-  });
-
-  it('should generate valid JS for waitFor', () => {
-    const js = compilePipeline([{ waitFor: '() => document.querySelector("#loaded")' }]);
-    assert.ok(js.includes('new Promise'));
-    assert.ok(js.includes('setInterval'));
-    assert.ok(js.includes('#loaded'));
-  });
-
-  it('should use custom timeout for waitFor', () => {
-    const js = compilePipeline([{ waitFor: '() => true', timeout: 5000 }]);
-    assert.ok(js.includes('5000'));
-  });
-
-  it('should generate valid JS for sleep', () => {
-    const js = compilePipeline([{ sleep: 200 }]);
-    assert.ok(js.includes('setTimeout'));
-    assert.ok(js.includes('200'));
-  });
-
-  it('should generate valid JS for return', () => {
-    const js = compilePipeline([{ return: '() => document.title' }]);
-    assert.ok(js.includes('document.title'));
-    assert.ok(js.includes('value:val'));
-  });
-
-  it('should throw on unrecognized micro-op', () => {
-    assert.throws(
-      () => compilePipeline([{ unknown: true }]),
-      { message: /unrecognized micro-op/ }
-    );
-  });
-
-  it('should combine multiple ops in sequence', () => {
-    const js = compilePipeline([
-      { find: '#user', fill: 'Alice' },
-      { find: '#pass', fill: 'secret' },
-      { find: '#submit', click: true }
-    ]);
-    assert.ok(js.includes('#user'));
-    assert.ok(js.includes('Alice'));
-    assert.ok(js.includes('#pass'));
-    assert.ok(js.includes('secret'));
-    assert.ok(js.includes('#submit'));
-    assert.ok(js.includes('.click()'));
-    assert.ok(js.includes('async function'));
-    assert.ok(js.includes('completed:true'));
-  });
-
-  it('should include error handling in generated code', () => {
-    const js = compilePipeline([{ find: '#el', click: true }]);
-    assert.ok(js.includes('catch'));
-    assert.ok(js.includes('failedAt'));
-    assert.ok(js.includes('completed:false'));
-  });
-
-  it('should track step index in error info', () => {
-    const js = compilePipeline([
-      { find: '#a', fill: 'x' },
-      { find: '#b', fill: 'y' }
-    ]);
-    assert.ok(js.includes('step:0'));
-    assert.ok(js.includes('step:1'));
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tests: executePipeline
-// ---------------------------------------------------------------------------
-
-describe('executePipeline', () => {
-  afterEach(() => { mock.reset(); });
-
-  it('should execute array form', async () => {
-    const pc = createMockPageController({ completed: true, steps: 2, results: [{ok:true},{ok:true}] });
-    const result = await executePipeline(pc, [
-      { find: '#a', fill: 'x' },
-      { find: '#b', fill: 'y' }
-    ]);
-
-    assert.strictEqual(result.completed, true);
-    assert.strictEqual(result.steps, 2);
-    assert.strictEqual(pc.evaluateInFrame.mock.calls.length, 1);
-    // Should use awaitPromise: true
-    assert.strictEqual(pc.evaluateInFrame.mock.calls[0].arguments[1].awaitPromise, true);
-  });
-
-  it('should execute object form with steps and timeout', async () => {
-    const pc = createMockPageController({ completed: true, steps: 1, results: [{ok:true}] });
-    const result = await executePipeline(pc, {
-      steps: [{ find: '#x', click: true }],
-      timeout: 5000
-    });
-
-    assert.strictEqual(result.completed, true);
-  });
-
-  it('should throw on empty array', async () => {
-    const pc = createMockPageController(null);
-    await assert.rejects(
-      () => executePipeline(pc, []),
-      { message: /non-empty array/ }
-    );
-  });
-
-  it('should throw on non-array params without steps', async () => {
-    const pc = createMockPageController(null);
-    await assert.rejects(
-      () => executePipeline(pc, { timeout: 1000 }),
-      { message: /non-empty array/ }
-    );
-  });
-
-  it('should throw on browser exception', async () => {
-    const pc = createMockPageController(undefined, { exception: 'TypeError: el is null' });
-    await assert.rejects(
-      () => executePipeline(pc, [{ find: '#missing', click: true }]),
-      { message: /pipeline error/ }
-    );
-  });
-
-  it('should timeout when evaluation hangs', async () => {
-    const pc = {
-      evaluateInFrame: mock.fn(() => new Promise(() => { /* never resolves */ }))
-    };
-    await assert.rejects(
-      () => executePipeline(pc, { steps: [{ find: '#x', click: true }], timeout: 50 }),
-      { message: /timed out after 50ms/ }
-    );
-  });
-
-  it('should return result value from browser', async () => {
-    const pipelineResult = { completed: false, failedAt: 0, error: 'not found: #x', results: [] };
-    const pc = createMockPageController(pipelineResult);
-    const result = await executePipeline(pc, [{ find: '#x', click: true }]);
-
-    assert.strictEqual(result.completed, false);
-    assert.strictEqual(result.failedAt, 0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tests: executeWriteSiteManifest and loadSiteManifest
-// ---------------------------------------------------------------------------
-
-describe('executeWriteSiteManifest', () => {
-  const testDomain = `test-dyn-${Date.now()}.example.com`;
-
-  afterEach(async () => {
-    await cleanupTestManifests([testDomain]);
-  });
-
-  it('should write a manifest file', async () => {
-    const result = await executeWriteSiteManifest({
-      domain: testDomain,
-      content: '# Test manifest\nContent here.'
-    });
-
-    assert.strictEqual(result.written, true);
-    assert.ok(result.path);
-    assert.strictEqual(result.domain, testDomain);
-
-    // Verify file was written
-    const content = await fs.readFile(result.path, 'utf8');
-    assert.strictEqual(content, '# Test manifest\nContent here.');
-  });
-
-  it('should require domain', async () => {
-    await assert.rejects(
-      () => executeWriteSiteManifest({ content: 'test' }),
-      { message: /requires domain and content/ }
-    );
-  });
-
-  it('should require content', async () => {
-    await assert.rejects(
-      () => executeWriteSiteManifest({ domain: 'example.com' }),
-      { message: /requires domain and content/ }
-    );
-  });
-
-  it('should throw on missing params', async () => {
-    await assert.rejects(
-      () => executeWriteSiteManifest(null),
-      { message: /requires domain and content/ }
-    );
-  });
-});
-
-describe('loadSiteManifest', () => {
-  const testDomain = `test-load-${Date.now()}.example.com`;
-
-  afterEach(async () => {
-    await cleanupTestManifests([testDomain]);
-  });
-
-  it('should return null when no manifest exists', async () => {
-    const result = await loadSiteManifest('nonexistent-domain-xyz-12345.com');
-    assert.strictEqual(result, null);
-  });
-
-  it('should return content when manifest exists', async () => {
-    // First write a manifest
-    await executeWriteSiteManifest({
-      domain: testDomain,
-      content: '# Loaded content'
-    });
-
-    const result = await loadSiteManifest(testDomain);
-    assert.strictEqual(result, '# Loaded content');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tests: generateLightManifest
-// ---------------------------------------------------------------------------
-
-describe('generateLightManifest', () => {
-  it('should generate markdown with detected frameworks', () => {
-    const detection = {
-      react: true,
-      nextjs: true,
-      bodyChildCount: 10,
-      interactiveCount: 25,
-      usesPushState: true,
-      hasMain: true,
-      mainSelector: '#root'
-    };
-
-    const md = generateLightManifest('example.com', detection);
-
-    assert.ok(md.includes('# example.com'));
-    assert.ok(md.includes('Fitted:'));
-    assert.ok(md.includes('light'));
-    assert.ok(md.includes('Fingerprint: bc10-ic25'));
-    assert.ok(md.includes('React'));
-    assert.ok(md.includes('Next.js'));
-    assert.ok(md.includes('SPA with pushState'));
-    assert.ok(md.includes('mainContent: `#root`'));
-  });
-
-  it('should generate markdown with no frameworks', () => {
-    const detection = {
-      bodyChildCount: 5,
-      interactiveCount: 3,
-      hasMain: false,
-      mainSelector: null
-    };
-
-    const md = generateLightManifest('plain.com', detection);
-
-    assert.ok(md.includes('# plain.com'));
-    assert.ok(md.includes('No major framework'));
-    assert.ok(md.includes('No <main>'));
-    assert.ok(md.includes('Fingerprint: bc5-ic3'));
-  });
-
-  it('should include all recognized frameworks', () => {
-    const detection = {
-      react: true,
-      vue: true,
-      angular: true,
-      svelte: true,
-      jquery: true,
-      turbo: true,
-      htmx: true,
-      nuxt: true,
-      remix: true,
-      bodyChildCount: 1,
-      interactiveCount: 1,
-      hasMain: false,
-      mainSelector: null
-    };
-
-    const md = generateLightManifest('multi.com', detection);
-
-    assert.ok(md.includes('React'));
-    assert.ok(md.includes('Vue'));
-    assert.ok(md.includes('Angular'));
-    assert.ok(md.includes('Svelte'));
-    assert.ok(md.includes('jQuery'));
-    assert.ok(md.includes('Turbo'));
-    assert.ok(md.includes('htmx'));
-    assert.ok(md.includes('Nuxt'));
-    assert.ok(md.includes('Remix'));
-  });
-
-  it('should include service worker info', () => {
-    const detection = {
-      hasServiceWorker: true,
-      bodyChildCount: 1,
-      interactiveCount: 1,
-      hasMain: false,
-      mainSelector: null
-    };
-
-    const md = generateLightManifest('sw.com', detection);
-    assert.ok(md.includes('Service Worker'));
-  });
-
-  it('should include generator meta', () => {
-    const detection = {
-      metaGenerator: 'WordPress 6.0',
-      bodyChildCount: 1,
-      interactiveCount: 1,
-      hasMain: false,
-      mainSelector: null
-    };
-
-    const md = generateLightManifest('wp.com', detection);
-    assert.ok(md.includes('Generator: WordPress 6.0'));
-  });
-
-  it('should include date in format YYYY-MM-DD', () => {
-    const detection = {
-      bodyChildCount: 0,
-      interactiveCount: 0,
-      hasMain: false,
-      mainSelector: null
-    };
-
-    const md = generateLightManifest('date.com', detection);
-    const datePattern = /\d{4}-\d{2}-\d{2}/;
-    assert.ok(datePattern.test(md));
-  });
-
-  it('should include notes section', () => {
-    const detection = {
-      bodyChildCount: 0,
-      interactiveCount: 0,
-      hasMain: false,
-      mainSelector: null
-    };
-
-    const md = generateLightManifest('notes.com', detection);
-    assert.ok(md.includes('## Notes'));
-    assert.ok(md.includes('Light fit only'));
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tests: runLightAutoFit
-// ---------------------------------------------------------------------------
-
-describe('runLightAutoFit', () => {
-  const testDomain = `autofit-${Date.now()}.example.com`;
-
-  afterEach(async () => {
-    await cleanupTestManifests([testDomain]);
-    mock.reset();
-  });
-
-  it('should return null when manifest already exists', async () => {
-    // Write a manifest first
-    await executeWriteSiteManifest({
-      domain: testDomain,
-      content: '# existing'
-    });
-
-    const pc = createMockPageController({});
-    const result = await runLightAutoFit(pc, `https://${testDomain}/page`);
-
-    assert.strictEqual(result, null);
-    // evaluateInFrame should NOT have been called since manifest exists
-    assert.strictEqual(pc.evaluateInFrame.mock.calls.length, 0);
-  });
-
-  it('should create manifest and return detection info on first visit', async () => {
-    const uniqueDomain = `autofit-new-${Date.now()}.example.com`;
-    const detection = {
-      react: true,
-      bodyChildCount: 12,
-      interactiveCount: 30,
-      hasMain: true,
-      mainSelector: '#app',
-      usesPushState: true,
-      title: 'Test App'
-    };
-
-    const pc = {
-      evaluateInFrame: mock.fn(() => Promise.resolve({
-        result: { value: detection },
-        exceptionDetails: undefined
-      }))
-    };
-
-    const result = await runLightAutoFit(pc, `https://${uniqueDomain}/`);
-
-    assert.ok(result);
-    assert.ok(result.domain);
-    assert.strictEqual(result.level, 'light');
-    assert.ok(result.frameworks.includes('react'));
-
-    // Verify the manifest was written
-    const manifest = await loadSiteManifest(result.domain);
-    assert.ok(manifest);
-    assert.ok(manifest.includes('React'));
-
-    // Cleanup
-    await cleanupTestManifests([uniqueDomain]);
-  });
-
-  it('should handle invalid URLs gracefully', async () => {
-    const pc = createMockPageController({});
-    const result = await runLightAutoFit(pc, 'not-a-valid-url');
-
-    assert.strictEqual(result, null);
-  });
-
-  it('should return null when browser detection fails', async () => {
-    const uniqueDomain = `autofit-fail-${Date.now()}.example.com`;
-    const pc = createMockPageController(undefined, { exception: 'eval error' });
-
-    const result = await runLightAutoFit(pc, `https://${uniqueDomain}/`);
-
-    assert.strictEqual(result, null);
-  });
-
-  it('should return null when detection returns no value', async () => {
-    const uniqueDomain = `autofit-noval-${Date.now()}.example.com`;
-    const pc = {
-      evaluateInFrame: mock.fn(() => Promise.resolve({
-        result: { value: null },
-        exceptionDetails: undefined
-      }))
-    };
-
-    const result = await runLightAutoFit(pc, `https://${uniqueDomain}/`);
-    assert.strictEqual(result, null);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tests: LIGHT_FIT_SCRIPT
-// ---------------------------------------------------------------------------
-
-describe('LIGHT_FIT_SCRIPT', () => {
-  it('should be a non-empty string', () => {
-    assert.ok(typeof LIGHT_FIT_SCRIPT === 'string');
-    assert.ok(LIGHT_FIT_SCRIPT.length > 0);
-  });
-
-  it('should detect common frameworks', () => {
-    assert.ok(LIGHT_FIT_SCRIPT.includes('React'));
-    assert.ok(LIGHT_FIT_SCRIPT.includes('Vue'));
-    assert.ok(LIGHT_FIT_SCRIPT.includes('Angular'));
-    assert.ok(LIGHT_FIT_SCRIPT.includes('jQuery'));
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tests: StepValidator - Dynamic step types
-// ---------------------------------------------------------------------------
-
-describe('StepValidator - pageFunction validation', () => {
-  it('should accept valid string form', () => {
-    const errors = validateStepInternal({ pageFunction: '() => document.title' });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should accept valid object form', () => {
-    const errors = validateStepInternal({ pageFunction: { fn: '() => 42', refs: true, timeout: 5000 } });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should reject empty string', () => {
-    const errors = validateStepInternal({ pageFunction: '' });
-    assert.ok(errors.some(e => e.includes('non-empty function string')));
-  });
-
-  it('should reject missing fn in object form', () => {
-    const errors = validateStepInternal({ pageFunction: { timeout: 1000 } });
-    assert.ok(errors.some(e => e.includes('non-empty fn string')));
-  });
-
-  it('should reject invalid refs type', () => {
-    const errors = validateStepInternal({ pageFunction: { fn: '() => 1', refs: 'yes' } });
-    assert.ok(errors.some(e => e.includes('refs must be a boolean')));
-  });
-
-  it('should reject invalid timeout', () => {
-    const errors = validateStepInternal({ pageFunction: { fn: '() => 1', timeout: -100 } });
-    assert.ok(errors.some(e => e.includes('timeout must be a non-negative')));
-  });
-
-  it('should reject non-string non-object form', () => {
-    const errors = validateStepInternal({ pageFunction: 42 });
-    assert.ok(errors.some(e => e.includes('function string or params object')));
-  });
-});
-
-describe('StepValidator - poll validation', () => {
-  it('should accept valid string form', () => {
-    const errors = validateStepInternal({ poll: '() => document.readyState === "complete"' });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should accept valid object form', () => {
-    const errors = validateStepInternal({ poll: { fn: '() => true', interval: 200, timeout: 10000 } });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should reject empty string', () => {
-    const errors = validateStepInternal({ poll: '' });
-    assert.ok(errors.some(e => e.includes('non-empty function string')));
-  });
-
-  it('should reject missing fn', () => {
-    const errors = validateStepInternal({ poll: { interval: 100 } });
-    assert.ok(errors.some(e => e.includes('non-empty fn string')));
-  });
-
-  it('should reject invalid interval', () => {
-    const errors = validateStepInternal({ poll: { fn: '() => true', interval: -50 } });
-    assert.ok(errors.some(e => e.includes('interval must be a non-negative')));
-  });
-
-  it('should reject invalid timeout', () => {
-    const errors = validateStepInternal({ poll: { fn: '() => true', timeout: 'long' } });
-    assert.ok(errors.some(e => e.includes('timeout must be a non-negative')));
-  });
-
-  it('should reject non-string non-object form', () => {
-    const errors = validateStepInternal({ poll: 123 });
-    assert.ok(errors.some(e => e.includes('function string or params object')));
-  });
-});
-
-describe('StepValidator - pipeline validation', () => {
-  it('should accept valid array of micro-ops', () => {
-    const errors = validateStepInternal({
-      pipeline: [
-        { find: '#name', fill: 'John' },
-        { find: '#submit', click: true }
-      ]
-    });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should accept valid object form with steps', () => {
-    const errors = validateStepInternal({
-      pipeline: {
-        steps: [{ find: '#btn', click: true }],
-        timeout: 5000
-      }
-    });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should reject empty array', () => {
-    const errors = validateStepInternal({ pipeline: [] });
-    assert.ok(errors.some(e => e.includes('non-empty array')));
-  });
-
-  it('should reject invalid micro-ops without find/waitFor/sleep/return', () => {
-    const errors = validateStepInternal({ pipeline: [{ something: true }] });
-    assert.ok(errors.some(e => e.includes('unrecognized micro-op')));
-  });
-
-  it('should reject find without action', () => {
-    const errors = validateStepInternal({ pipeline: [{ find: '#el' }] });
-    assert.ok(errors.some(e => e.includes('find requires an action')));
-  });
-
-  it('should accept find with fill action', () => {
-    const errors = validateStepInternal({ pipeline: [{ find: '#el', fill: 'val' }] });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should accept find with click action', () => {
-    const errors = validateStepInternal({ pipeline: [{ find: '#el', click: true }] });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should accept find with type action', () => {
-    const errors = validateStepInternal({ pipeline: [{ find: '#el', type: 'text' }] });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should accept find with check action', () => {
-    const errors = validateStepInternal({ pipeline: [{ find: '#el', check: true }] });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should accept find with select action', () => {
-    const errors = validateStepInternal({ pipeline: [{ find: '#el', select: 'opt' }] });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should accept waitFor micro-op', () => {
-    const errors = validateStepInternal({ pipeline: [{ waitFor: '() => true' }] });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should accept sleep micro-op', () => {
-    const errors = validateStepInternal({ pipeline: [{ sleep: 500 }] });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should accept return micro-op', () => {
-    const errors = validateStepInternal({ pipeline: [{ return: '() => document.title' }] });
-    assert.strictEqual(errors.length, 0);
-  });
-
-  it('should reject invalid timeout on object form', () => {
-    const errors = validateStepInternal({
-      pipeline: {
-        steps: [{ find: '#el', click: true }],
-        timeout: -1
-      }
-    });
-    assert.ok(errors.some(e => e.includes('timeout must be a non-negative')));
-  });
-
-  it('should report errors for multiple invalid ops', () => {
-    const errors = validateStepInternal({
-      pipeline: [
-        { find: '#a' },  // missing action
-        { bad: true },   // unrecognized
-        { find: '#b', fill: 'ok' }  // valid
-      ]
-    });
-    assert.ok(errors.length >= 2);
-  });
-});
-
-describe('StepValidator - writeSiteManifest validation', () => {
+describe('StepValidator - writeSiteProfile validation', () => {
   it('should accept valid params', () => {
     const errors = validateStepInternal({
-      writeSiteManifest: { domain: 'example.com', content: '# manifest' }
+      writeSiteProfile: { domain: 'example.com', content: '# profile' }
     });
     assert.strictEqual(errors.length, 0);
   });
 
   it('should reject missing domain', () => {
     const errors = validateStepInternal({
-      writeSiteManifest: { content: '# manifest' }
+      writeSiteProfile: { content: '# profile' }
     });
     assert.ok(errors.some(e => e.includes('non-empty domain string')));
   });
 
   it('should reject missing content', () => {
     const errors = validateStepInternal({
-      writeSiteManifest: { domain: 'example.com' }
+      writeSiteProfile: { domain: 'example.com' }
     });
     assert.ok(errors.some(e => e.includes('non-empty content string')));
   });
 
   it('should reject non-object params', () => {
-    const errors = validateStepInternal({ writeSiteManifest: 'test' });
+    const errors = validateStepInternal({ writeSiteProfile: 'test' });
     assert.ok(errors.some(e => e.includes('requires an object')));
   });
 });
@@ -1052,12 +378,9 @@ describe('STEP_TYPES includes dynamic steps', () => {
     assert.ok(STEP_TYPES.includes('poll'));
   });
 
-  it('should include pipeline', () => {
-    assert.ok(STEP_TYPES.includes('pipeline'));
-  });
 
-  it('should include writeSiteManifest', () => {
-    assert.ok(STEP_TYPES.includes('writeSiteManifest'));
+  it('should include writeSiteProfile', () => {
+    assert.ok(STEP_TYPES.includes('writeSiteProfile'));
   });
 });
 
@@ -1125,33 +448,19 @@ describe('step-executors dispatch for dynamic steps', () => {
     assert.ok(result.output.resolved);
   });
 
-  it('should dispatch pipeline step', async () => {
-    mockDeps.pageController.evaluateInFrame = mock.fn(() => Promise.resolve({
-      result: { value: { completed: true, steps: 1, results: [{ok:true}] } },
-      exceptionDetails: undefined
-    }));
-
-    const result = await executeStep(mockDeps, {
-      pipeline: [{ find: '#btn', click: true }]
-    });
 
-    assert.strictEqual(result.action, 'pipeline');
-    assert.strictEqual(result.status, 'ok');
-    assert.ok(result.output.completed);
-  });
-
-  it('should dispatch writeSiteManifest step', async () => {
+  it('should dispatch writeSiteProfile step', async () => {
     const uniqueDomain = `dispatch-test-${Date.now()}.example.com`;
     const result = await executeStep(mockDeps, {
-      writeSiteManifest: { domain: uniqueDomain, content: '# test' }
+      writeSiteProfile: { domain: uniqueDomain, content: '# test' }
     });
 
-    assert.strictEqual(result.action, 'writeSiteManifest');
+    assert.strictEqual(result.action, 'writeSiteProfile');
     assert.strictEqual(result.status, 'ok');
     assert.ok(result.output.written);
 
     // Cleanup
-    await cleanupTestManifests([uniqueDomain]);
+    await cleanupTestProfiles([uniqueDomain]);
   });
 });
 
@@ -1315,7 +624,7 @@ describe('step-executors hooks', () => {
   });
 });
 
-describe('step-executors goto manifest integration', () => {
+describe('step-executors goto profile integration', () => {
   let mockDeps;
   const testDomain = `goto-test-${Date.now()}.example.com`;
 
@@ -1330,29 +639,19 @@ describe('step-executors goto manifest integration', () => {
     mockDeps = {
       pageController: {
         evaluateInFrame: mock.fn((expr, opts) => {
-          // For the URL check in goto
           if (expr === 'window.location.href') {
             return Promise.resolve({
               result: { value: `https://${testDomain}/page` },
               exceptionDetails: undefined
             });
           }
-          // For light auto-fit detection
           return Promise.resolve({
-            result: {
-              value: {
-                react: true,
-                bodyChildCount: 5,
-                interactiveCount: 10,
-                hasMain: true,
-                mainSelector: 'main',
-                title: 'Test'
-              }
-            },
+            result: { value: null },
             exceptionDetails: undefined
           });
         }),
         navigate: mock.fn(() => Promise.resolve()),
+        waitForNetworkSettle: mock.fn(() => Promise.resolve({ settled: true, pendingCount: 0 })),
         getUrl: mock.fn(() => Promise.resolve(`https://${testDomain}/page`)),
         session: { send: mockSessionSend }
       },
@@ -1365,35 +664,36 @@ describe('step-executors goto manifest integration', () => {
   });
 
   afterEach(async () => {
-    await cleanupTestManifests([testDomain]);
+    await cleanupTestProfiles([testDomain]);
     mock.reset();
   });
 
-  it('should load existing manifest on goto', async () => {
-    // Write a manifest first
-    await executeWriteSiteManifest({
+  it('should load existing profile on goto', async () => {
+    // Write a profile first
+    await executeWriteSiteProfile({
       domain: testDomain,
-      content: '# Pre-existing manifest'
+      content: '# Pre-existing profile'
     });
 
     const result = await executeStep(mockDeps, { goto: `https://${testDomain}/page` });
 
     assert.strictEqual(result.action, 'goto');
     assert.strictEqual(result.status, 'ok');
-    assert.ok(result.siteManifest);
-    assert.ok(result.siteManifest.includes('Pre-existing manifest'));
+    assert.ok(result.siteProfile);
+    assert.ok(result.siteProfile.includes('Pre-existing profile'));
   });
 
-  it('should run light auto-fit on goto for unknown domain', async () => {
-    // Make sure no manifest exists
-    await cleanupTestManifests([testDomain]);
+  it('should return profileAvailable false on goto for unknown domain', async () => {
+    // Make sure no profile exists
+    await cleanupTestProfiles([testDomain]);
 
     const result = await executeStep(mockDeps, { goto: `https://${testDomain}/page` });
 
     assert.strictEqual(result.action, 'goto');
     assert.strictEqual(result.status, 'ok');
-    // Should have created a fit
-    assert.ok(result.fitted || result.siteManifest);
+    assert.strictEqual(result.profileAvailable, false);
+    assert.strictEqual(result.profileDomain, testDomain);
+
   });
 });
 
@@ -1407,8 +707,7 @@ describe('validateSteps for dynamic steps', () => {
       { goto: 'https://example.com' },
       { pageFunction: '() => document.title' },
       { poll: { fn: '() => true', timeout: 5000 } },
-      { pipeline: [{ find: '#btn', click: true }] },
-      { writeSiteManifest: { domain: 'example.com', content: '# test' } }
+      { writeSiteProfile: { domain: 'example.com', content: '# test' } }
     ]);
     assert.strictEqual(result.valid, true);
     assert.strictEqual(result.errors.length, 0);
@@ -1418,10 +717,9 @@ describe('validateSteps for dynamic steps', () => {
     const result = validateSteps([
       { pageFunction: '' },
       { poll: { interval: 100 } },
-      { pipeline: [] },
-      { writeSiteManifest: { domain: 'x' } }
+      { writeSiteProfile: { domain: 'x' } }
     ]);
     assert.strictEqual(result.valid, false);
-    assert.strictEqual(result.errors.length, 4);
+    assert.strictEqual(result.errors.length, 3);
   });
 });