@outputai/core 0.3.3-next.b4a190e.0 → 0.3.3-next.cb14409.0

package/src/worker/loader.spec.js

@@ -1,6 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
+import { staticMatchers } from './loader_tools.js';
 
 vi.mock( '#consts', () => ( {
   ACTIVITY_SEND_HTTP_REQUEST: '__internal#sendHttpRequest',
@@ -18,10 +19,22 @@ vi.mock( '#internal_activities', () => ( {
   getTraceDestinations: getTraceDestinationsMock
 } ) );
 
-const importComponentsMock = vi.fn();
+const { importComponentsMock, findSharedActivitiesFromWorkflowsMock, findWorkflowsInNodeModulesMock, matchFilesMock } = vi.hoisted( () => ( {
+  importComponentsMock: vi.fn(),
+  findSharedActivitiesFromWorkflowsMock: vi.fn(),
+  findWorkflowsInNodeModulesMock: vi.fn(),
+  matchFilesMock: vi.fn()
+} ) );
+
 vi.mock( './loader_tools.js', async importOriginal => {
   const actual = await importOriginal();
-  return { ...actual, importComponents: importComponentsMock };
+  return {
+    ...actual,
+    importComponents: importComponentsMock,
+    findSharedActivitiesFromWorkflows: findSharedActivitiesFromWorkflowsMock,
+    findWorkflowsInNodeModules: findWorkflowsInNodeModulesMock,
+    matchFiles: matchFilesMock
+  };
 } );
 
 const fsMocks = vi.hoisted( () => ( {
@@ -38,12 +51,19 @@ vi.mock( 'node:fs', () => ( {
 describe( 'worker/loader', () => {
   beforeEach( () => {
     vi.clearAllMocks();
+    importComponentsMock.mockReset();
+    importComponentsMock.mockImplementation( async function *() {} );
+    findSharedActivitiesFromWorkflowsMock.mockReset();
+    findSharedActivitiesFromWorkflowsMock.mockReturnValue( [] );
+    findWorkflowsInNodeModulesMock.mockReset();
+    findWorkflowsInNodeModulesMock.mockReturnValue( [] );
+    matchFilesMock.mockReset();
+    matchFilesMock.mockReturnValue( [] );
   } );
 
   it( 'loadActivities returns map including system activity and writes options file', async () => {
     const { loadActivities } = await import( './loader.js' );
 
-    // First call: workflow directory scan (options.activityOptions propagated to activity options file)
     importComponentsMock.mockImplementationOnce( async function *() {
       yield {
         fn: () => {},
@@ -51,7 +71,6 @@ describe( 'worker/loader', () => {
         path: '/a/steps.js'
       };
     } );
-    // Second call: shared activities scan (no results)
     importComponentsMock.mockImplementationOnce( async function *() {} );
 
     const workflows = [ { name: 'A', path: '/a/workflow.js' } ];
@@ -59,7 +78,6 @@ describe( 'worker/loader', () => {
     expect( activities['A#Act1'] ).toBeTypeOf( 'function' );
     expect( activities['__internal#sendHttpRequest'] ).toBe( sendHttpRequestMock );
 
-    // options file written with the collected activityOptions map
     expect( fsMocks.writeFileSync ).toHaveBeenCalledTimes( 1 );
     const [ writtenPath, contents ] = fsMocks.writeFileSync.mock.calls[0];
     expect( writtenPath ).toMatch( /temp\/__activity_options\.js$/ );
@@ -86,15 +104,212 @@ describe( 'worker/loader', () => {
     expect( written['A#EmptyOptions'] ).toBeUndefined();
   } );
 
-  it( 'loadWorkflows returns array of workflows with metadata', async () => {
-    const { loadWorkflows } = await import( './loader.js' );
+  it( 'loadActivities throws when two activities in the same workflow share a name', async () => {
+    const { loadActivities } = await import( './loader.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { fn: () => {}, metadata: { name: 'DuplicateActivity' }, path: '/a/steps.js' };
+      yield { fn: () => {}, metadata: { name: 'DuplicateActivity' }, path: '/a/evaluators.js' };
+    } );
 
+    await expect( loadActivities( '/root', [ { name: 'A', path: '/a/workflow.js' } ] ) ).rejects.toThrow(
+      'Activity "DuplicateActivity" in workflow "A" conflicts with another activity in the same workflow. \
+Activity names must be unique within a workflow.'
+    );
+  } );
+
+  it( 'loadActivities throws when two shared activities share a name', async () => {
+    const { loadActivities } = await import( './loader.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {} );
     importComponentsMock.mockImplementationOnce( async function *() {
-      yield { metadata: { name: 'Flow1', description: 'd' }, path: '/b/workflow.js' };
+      yield { fn: () => {}, metadata: { name: 'DuplicateShared' }, path: '/root/shared/steps/a.js' };
+      yield { fn: () => {}, metadata: { name: 'DuplicateShared' }, path: '/root/shared/evaluators/a.js' };
+    } );
+
+    await expect( loadActivities( '/root', [ { name: 'A', path: '/a/workflow.js' } ] ) ).rejects.toThrow(
+      'Shared activity "DuplicateShared" conflicts with another shared activity. Shared activity names must be unique.'
+    );
+  } );
+
+  describe( 'loadWorkflows', () => {
+    it( 'returns local workflows from importComponents with metadata spread onto each entry', async () => {
+      const { loadWorkflows } = await import( './loader.js' );
+      const localFiles = [ { path: '/b/workflow.js', url: 'file:///b/workflow.js' } ];
+      matchFilesMock.mockReturnValueOnce( localFiles );
+
+      importComponentsMock.mockImplementationOnce( async function *() {
+        yield { metadata: { name: 'Flow1', description: 'd' }, path: '/b/workflow.js' };
+      } );
+
+      const workflows = await loadWorkflows( '/root' );
+      expect( workflows ).toEqual( [ { name: 'Flow1', description: 'd', path: '/b/workflow.js', external: false } ] );
+      expect( importComponentsMock ).toHaveBeenNthCalledWith( 1, localFiles );
+      expect( findWorkflowsInNodeModulesMock ).toHaveBeenCalledOnce();
+      expect( findWorkflowsInNodeModulesMock ).toHaveBeenCalledWith( '/root' );
+    } );
+
+    it( 'calls matchFiles with rootDir and workflowFile matcher', async () => {
+      const { loadWorkflows } = await import( './loader.js' );
+      const localFiles = [ { path: '/my/app/workflow.js', url: 'file:///my/app/workflow.js' } ];
+      const externalFiles = [ { path: '/my/app/node_modules/pkg/workflow.js', url: 'file:///my/app/node_modules/pkg/workflow.js' } ];
+      matchFilesMock.mockReturnValueOnce( localFiles );
+      findWorkflowsInNodeModulesMock.mockReturnValue( externalFiles );
+
+      await loadWorkflows( '/my/app' );
+
+      expect( matchFilesMock ).toHaveBeenCalledOnce();
+      expect( matchFilesMock ).toHaveBeenCalledWith( '/my/app', [ staticMatchers.workflowFile ] );
+      expect( importComponentsMock ).toHaveBeenCalledTimes( 1 );
+      expect( importComponentsMock ).toHaveBeenNthCalledWith( 1, [ ...localFiles, ...externalFiles ] );
+      expect( findWorkflowsInNodeModulesMock ).toHaveBeenCalledOnce();
+      expect( findWorkflowsInNodeModulesMock ).toHaveBeenCalledWith( '/my/app' );
+    } );
+
+    it( 'appends node_modules workflows after local ones and sets external: true', async () => {
+      const { loadWorkflows } = await import( './loader.js' );
+
+      importComponentsMock.mockImplementationOnce( async function *() {
+        yield { metadata: { name: 'LocalFlow', description: 'local' }, path: '/my/app/workflows/wf/workflow.js' };
+        yield {
+          metadata: { name: '__sum_numbers', description: 'from catalog' },
+          path: '/my/app/node_modules/catalog_pkg/src/w/workflow.js'
+        };
+      } );
+      findWorkflowsInNodeModulesMock.mockReturnValue( [ { path: '/my/app/node_modules/catalog_pkg/src/w/workflow.js' } ] );
+
+      const workflows = await loadWorkflows( '/my/app' );
+      expect( workflows ).toEqual( [
+        { name: 'LocalFlow', description: 'local', path: '/my/app/workflows/wf/workflow.js', external: false },
+        {
+          name: '__sum_numbers',
+          description: 'from catalog',
+          path: '/my/app/node_modules/catalog_pkg/src/w/workflow.js',
+          external: true
+        }
+      ] );
+    } );
+
+    it( 'returns only external workflows when the project root has none', async () => {
+      const { loadWorkflows } = await import( './loader.js' );
+
+      importComponentsMock.mockImplementationOnce( async function *() {
+        yield { metadata: { name: 'PkgFlow', description: 'pkg' }, path: '/proj/node_modules/a/w/workflow.js' };
+      } );
+      findWorkflowsInNodeModulesMock.mockReturnValue( [ { path: '/proj/node_modules/a/w/workflow.js' } ] );
+
+      const workflows = await loadWorkflows( '/proj' );
+      expect( workflows ).toEqual( [
+        {
+          name: 'PkgFlow',
+          description: 'pkg',
+          path: '/proj/node_modules/a/w/workflow.js',
+          external: true
+        }
+      ] );
+    } );
+
+    it( 'throws when a local workflow path is under a shared directory', async () => {
+      const { loadWorkflows } = await import( './loader.js' );
+      importComponentsMock.mockImplementationOnce( async function *() {
+        yield { metadata: { name: 'Invalid' }, path: '/root/shared/workflow.js' };
+      } );
+
+      await expect( loadWorkflows( '/root' ) ).rejects.toThrow( 'Workflow directory can\'t be named "shared"' );
+      expect( findWorkflowsInNodeModulesMock ).toHaveBeenCalledOnce();
+    } );
+
+    it( 'throws when a workflow name conflicts with an earlier workflow name', async () => {
+      const { loadWorkflows } = await import( './loader.js' );
+      importComponentsMock.mockImplementationOnce( async function *() {
+        yield { metadata: { name: 'duplicate' }, path: '/root/a/workflow.js' };
+        yield { metadata: { name: 'duplicate' }, path: '/root/b/workflow.js' };
+      } );
+
+      await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
+        'Workflow name "duplicate" conflicts with another workflow or alias. Workflow names and aliases must be unique.'
+      );
+    } );
+
+    it( 'throws when a workflow name conflicts with an earlier alias', async () => {
+      const { loadWorkflows } = await import( './loader.js' );
+      importComponentsMock.mockImplementationOnce( async function *() {
+        yield { metadata: { name: 'alpha', aliases: [ 'legacy' ] }, path: '/root/a/workflow.js' };
+        yield { metadata: { name: 'legacy' }, path: '/root/b/workflow.js' };
+      } );
+
+      await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
+        'Workflow name "legacy" conflicts with another workflow or alias. Workflow names and aliases must be unique.'
+      );
+    } );
+
+    it( 'throws when an alias conflicts with an earlier workflow name', async () => {
+      const { loadWorkflows } = await import( './loader.js' );
+      importComponentsMock.mockImplementationOnce( async function *() {
+        yield { metadata: { name: 'alpha' }, path: '/root/a/workflow.js' };
+        yield { metadata: { name: 'beta', aliases: [ 'alpha' ] }, path: '/root/b/workflow.js' };
+      } );
+
+      await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
+        'Workflow "beta" alias "alpha" conflicts with another workflow or alias. Workflow names and aliases must be unique.'
+      );
+    } );
+
+    it( 'throws when an alias conflicts with an earlier alias', async () => {
+      const { loadWorkflows } = await import( './loader.js' );
+      importComponentsMock.mockImplementationOnce( async function *() {
+        yield { metadata: { name: 'alpha', aliases: [ 'shared_alias' ] }, path: '/root/a/workflow.js' };
+        yield { metadata: { name: 'beta', aliases: [ 'shared_alias' ] }, path: '/root/b/workflow.js' };
+      } );
+
+      await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
+        'Workflow "beta" alias "shared_alias" conflicts with another workflow or alias. Workflow names and aliases must be unique.'
+      );
+    } );
+
+    it( 'throws when an alias is identical to its workflow name', async () => {
+      const { loadWorkflows } = await import( './loader.js' );
+      importComponentsMock.mockImplementationOnce( async function *() {
+        yield { metadata: { name: 'alpha', aliases: [ 'alpha' ] }, path: '/root/a/workflow.js' };
+      } );
+
+      await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
+        'Workflow "alpha" alias "alpha" conflicts with another workflow or alias. Workflow names and aliases must be unique.'
+      );
     } );
 
-    const workflows = await loadWorkflows( '/root' );
-    expect( workflows ).toEqual( [ { name: 'Flow1', description: 'd', path: '/b/workflow.js' } ] );
+    it( 'allows workflow names and aliases that only differ by case', async () => {
+      const { loadWorkflows } = await import( './loader.js' );
+      importComponentsMock.mockImplementationOnce( async function *() {
+        yield { metadata: { name: 'Alpha', aliases: [ 'Legacy' ] }, path: '/root/a/workflow.js' };
+        yield { metadata: { name: 'alpha', aliases: [ 'legacy' ] }, path: '/root/b/workflow.js' };
+      } );
+
+      await expect( loadWorkflows( '/root' ) ).resolves.toEqual( [
+        { name: 'Alpha', aliases: [ 'Legacy' ], path: '/root/a/workflow.js', external: false },
+        { name: 'alpha', aliases: [ 'legacy' ], path: '/root/b/workflow.js', external: false }
+      ] );
+    } );
+
+    it( 'throws when a workflow name is reserved for the internal catalog', async () => {
+      const { loadWorkflows } = await import( './loader.js' );
+      importComponentsMock.mockImplementationOnce( async function *() {
+        yield { metadata: { name: 'catalog' }, path: '/root/catalog/workflow.js' };
+      } );
+
+      await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
+        'Workflow name "catalog" is reserved for the internal catalog workflow.'
+      );
+    } );
+
+    it( 'throws when a workflow alias is reserved for the internal catalog', async () => {
+      const { loadWorkflows } = await import( './loader.js' );
+      importComponentsMock.mockImplementationOnce( async function *() {
+        yield { metadata: { name: 'alpha', aliases: [ 'catalog' ] }, path: '/root/a/workflow.js' };
+      } );
+
+      await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
+        'Workflow "alpha" alias "catalog" is reserved for the internal catalog workflow.'
+      );
+    } );
   } );
 
   it( 'createWorkflowsEntryPoint writes index and returns its path', async () => {
@@ -123,89 +338,69 @@ describe( 'worker/loader', () => {
     expect( contents ).toContain( 'export { default as W_legacy } from \'/abs/wf.js\';' );
   } );
 
-  it( 'createWorkflowsEntryPoint throws on alias conflicting with primary name', async () => {
-    const { createWorkflowsEntryPoint } = await import( './loader.js' );
-
-    const workflows = [
-      { name: 'alpha', path: '/a.js', aliases: [] },
-      { name: 'beta', path: '/b.js', aliases: [ 'alpha' ] }
-    ];
-    expect( () => createWorkflowsEntryPoint( workflows ) ).toThrow( /Alias "alpha" on workflow "beta" conflicts with workflow "alpha"/ );
-  } );
-
-  it( 'createWorkflowsEntryPoint throws on alias conflicting with another alias', async () => {
-    const { createWorkflowsEntryPoint } = await import( './loader.js' );
-
-    const workflows = [
-      { name: 'alpha', path: '/a.js', aliases: [ 'shared_alias' ] },
-      { name: 'beta', path: '/b.js', aliases: [ 'shared_alias' ] }
-    ];
-    expect( () => createWorkflowsEntryPoint( workflows ) ).toThrow( /Alias "shared_alias" on workflow "beta" conflicts with/ );
-  } );
-
-  it( 'createWorkflowsEntryPoint throws on alias identical to own name', async () => {
-    const { createWorkflowsEntryPoint } = await import( './loader.js' );
-
-    const workflows = [ { name: 'alpha', path: '/a.js', aliases: [ 'alpha' ] } ];
-    expect( () => createWorkflowsEntryPoint( workflows ) ).toThrow( /Workflow "alpha" has an alias identical to its own name/ );
-  } );
-
-  it( 'createWorkflowsEntryPoint catches case-insensitive alias collision with primary name', async () => {
-    const { createWorkflowsEntryPoint } = await import( './loader.js' );
-
-    const workflows = [
-      { name: 'Alpha', path: '/a.js', aliases: [] },
-      { name: 'beta', path: '/b.js', aliases: [ 'alpha' ] }
-    ];
-    expect( () => createWorkflowsEntryPoint( workflows ) ).toThrow( /Alias "alpha" on workflow "beta" conflicts with workflow "Alpha"/ );
-  } );
-
-  it( 'createWorkflowsEntryPoint catches case-insensitive alias-to-alias collision', async () => {
-    const { createWorkflowsEntryPoint } = await import( './loader.js' );
-
-    const workflows = [
-      { name: 'alpha', path: '/a.js', aliases: [ 'Legacy' ] },
-      { name: 'beta', path: '/b.js', aliases: [ 'legacy' ] }
-    ];
-    expect( () => createWorkflowsEntryPoint( workflows ) ).toThrow( /Alias "legacy" on workflow "beta" conflicts with/ );
-  } );
-
   it( 'loadActivities uses folder-based matchers for steps/evaluators and shared', async () => {
     const { loadActivities } = await import( './loader.js' );
-    // First call (workflow dir): no results
+    const workflowFiles = [ { path: '/a/steps/foo.js' } ];
+    const sharedFiles = [ { path: '/root/shared/steps/baz.js' } ];
+    matchFilesMock.mockReturnValueOnce( workflowFiles );
+    matchFilesMock.mockReturnValueOnce( sharedFiles );
     importComponentsMock.mockImplementationOnce( async function *() {} );
-    // Second call (shared): no results
     importComponentsMock.mockImplementationOnce( async function *() {} );
 
     const workflows = [ { name: 'A', path: '/a/workflow.js' } ];
     await loadActivities( '/root', workflows );
 
-    // First invocation should target the workflow directory with folder/file matchers
-    expect( importComponentsMock ).toHaveBeenCalledTimes( 2 );
-    const [ firstDir, firstMatchers ] = importComponentsMock.mock.calls[0];
+    expect( matchFilesMock ).toHaveBeenCalledTimes( 2 );
+    const [ firstDir, firstMatchers ] = matchFilesMock.mock.calls[0];
     expect( firstDir ).toBe( '/a' );
     expect( Array.isArray( firstMatchers ) ).toBe( true );
-    // Should match folder-based steps and evaluators files
     expect( firstMatchers.some( fn => fn( '/a/steps/foo.js' ) ) ).toBe( true );
     expect( firstMatchers.some( fn => fn( '/a/evaluators/bar.js' ) ) ).toBe( true );
-    // And also direct file names
     expect( firstMatchers.some( fn => fn( '/a/steps.js' ) ) ).toBe( true );
     expect( firstMatchers.some( fn => fn( '/a/evaluators.js' ) ) ).toBe( true );
 
-    // Second invocation should target root with shared matchers
-    const [ secondDir, secondMatchers ] = importComponentsMock.mock.calls[1];
+    const [ secondDir, secondMatchers ] = matchFilesMock.mock.calls[1];
     expect( secondDir ).toBe( '/root' );
     expect( secondMatchers.some( fn => fn( '/root/shared/steps/baz.js' ) ) ).toBe( true );
     expect( secondMatchers.some( fn => fn( '/root/shared/evaluators/qux.js' ) ) ).toBe( true );
+
+    expect( importComponentsMock ).toHaveBeenCalledTimes( 2 );
+    expect( importComponentsMock ).toHaveBeenNthCalledWith( 1, workflowFiles );
+    expect( importComponentsMock ).toHaveBeenNthCalledWith( 2, sharedFiles );
+  } );
+
+  it( 'loads shared activities from external workflow packages', async () => {
+    const { loadActivities } = await import( './loader.js' );
+    const externalSharedFiles = [ { path: '/root/node_modules/pkg/shared/steps/prepare.js' } ];
+    const localWorkflow = { name: 'Local', path: '/root/workflows/local/workflow.js' };
+    const externalWorkflow = { name: 'External', path: '/root/node_modules/pkg/workflows/a/workflow.js', external: true };
+    findSharedActivitiesFromWorkflowsMock.mockReturnValue( externalSharedFiles );
+    importComponentsMock.mockImplementationOnce( async function *() {} );
+    importComponentsMock.mockImplementationOnce( async function *() {} );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield {
+        fn: () => {},
+        metadata: { name: 'ExternalShared', options: { activityOptions: { retry: { maximumAttempts: 2 } } } },
+        path: '/root/node_modules/pkg/shared/steps/prepare.js'
+      };
+    } );
+
+    const activities = await loadActivities( '/root', [ localWorkflow, externalWorkflow ] );
+
+    expect( findSharedActivitiesFromWorkflowsMock ).toHaveBeenCalledWith( [ externalWorkflow ] );
+    expect( importComponentsMock ).toHaveBeenNthCalledWith( 3, externalSharedFiles );
+    expect( activities['$shared#ExternalShared'] ).toBeTypeOf( 'function' );
+    const written = JSON.parse(
+      fsMocks.writeFileSync.mock.calls[0][1].replace( /^export default\s*/, '' ).replace( /;\s*$/, '' )
+    );
+    expect( written['$shared#ExternalShared'] ).toEqual( { retry: { maximumAttempts: 2 } } );
   } );
 
   it( 'loadActivities includes nested workflow steps and shared evaluators', async () => {
     const { loadActivities } = await import( './loader.js' );
-    // Workflow dir scan returns a nested step
     importComponentsMock.mockImplementationOnce( async function *() {
       yield { fn: () => {}, metadata: { name: 'ActNested' }, path: '/a/steps/foo.js' };
     } );
-    // Shared scan returns a shared evaluator
     importComponentsMock.mockImplementationOnce( async function *() {
       yield { fn: () => {}, metadata: { name: 'SharedEval' }, path: '/root/shared/evaluators/bar.js' };
     } );
@@ -216,24 +411,14 @@ describe( 'worker/loader', () => {
     expect( activities['$shared#SharedEval'] ).toBeTypeOf( 'function' );
   } );
 
-  it( 'loadWorkflows throws when workflow is under shared directory', async () => {
-    const { loadWorkflows } = await import( './loader.js' );
-    importComponentsMock.mockImplementationOnce( async function *() {
-      yield { metadata: { name: 'Invalid' }, path: '/root/shared/workflow.js' };
-    } );
-    await expect( loadWorkflows( '/root' ) ).rejects.toThrow( 'Workflow directory can\'t be named \"shared\"' );
-  } );
-
   it( 'collects workflow nested steps and evaluators across multiple subfolders', async () => {
     const { loadActivities } = await import( './loader.js' );
-    // Workflow dir scan returns nested steps and evaluators
     importComponentsMock.mockImplementationOnce( async function *() {
       yield { fn: () => {}, metadata: { name: 'StepPrimary' }, path: '/a/steps/primary/foo.js' };
       yield { fn: () => {}, metadata: { name: 'StepSecondary' }, path: '/a/steps/secondary/bar.js' };
       yield { fn: () => {}, metadata: { name: 'EvalPrimary' }, path: '/a/evaluators/primary/baz.js' };
       yield { fn: () => {}, metadata: { name: 'EvalSecondary' }, path: '/a/evaluators/secondary/qux.js' };
     } );
-    // Shared scan returns nothing for this test
     importComponentsMock.mockImplementationOnce( async function *() {} );
 
     const workflows = [ { name: 'A', path: '/a/workflow.js' } ];
@@ -246,9 +431,7 @@ describe( 'worker/loader', () => {
 
   it( 'collects shared nested steps and evaluators across multiple subfolders', async () => {
     const { loadActivities } = await import( './loader.js' );
-    // Workflow dir scan returns nothing for this test
     importComponentsMock.mockImplementationOnce( async function *() {} );
-    // Shared scan returns nested steps and evaluators
     importComponentsMock.mockImplementationOnce( async function *() {
       yield { fn: () => {}, metadata: { name: 'SharedStepPrimary' }, path: '/root/shared/steps/primary/a.js' };
       yield { fn: () => {}, metadata: { name: 'SharedStepSecondary' }, path: '/root/shared/steps/secondary/b.js' };
@@ -272,14 +455,14 @@ describe( 'worker/loader', () => {
       expect( fsMocks.existsSync ).toHaveBeenCalledWith( join( '/root', 'package.json' ) );
     } );
 
-    it( 'imports hook files listed in package.json output.hookFiles', async () => {
+    it( 'imports hook files listed in package.json outputai.hookFiles', async () => {
       vi.doUnmock( 'node:fs' );
       vi.resetModules();
       const fs = await import( 'node:fs' );
       const tmpDir = fs.mkdtempSync( join( tmpdir(), 'loader-spec-' ) );
       try {
         fs.writeFileSync( join( tmpDir, 'package.json' ), JSON.stringify( {
-          output: { hookFiles: [ 'hook.js' ] }
+          outputai: { hookFiles: [ 'hook.js' ] }
         } ) );
         fs.writeFileSync( join( tmpDir, 'hook.js' ), 'globalThis.__loadHooksTestLoaded = true;' );
 
@@ -291,5 +474,25 @@ describe( 'worker/loader', () => {
         fs.rmSync( tmpDir, { recursive: true, force: true } );
       }
     } );
+
+    it( 'imports hook files from legacy package.json output.hookFiles', async () => {
+      vi.doUnmock( 'node:fs' );
+      vi.resetModules();
+      const fs = await import( 'node:fs' );
+      const tmpDir = fs.mkdtempSync( join( tmpdir(), 'loader-spec-' ) );
+      try {
+        fs.writeFileSync( join( tmpDir, 'package.json' ), JSON.stringify( {
+          output: { hookFiles: [ 'legacy_hook.js' ] }
+        } ) );
+        fs.writeFileSync( join( tmpDir, 'legacy_hook.js' ), 'globalThis.__loadHooksLegacyTestLoaded = true;' );
+
+        const { loadHooks } = await import( './loader.js' );
+        await loadHooks( tmpDir );
+        expect( globalThis.__loadHooksLegacyTestLoaded ).toBe( true );
+      } finally {
+        delete globalThis.__loadHooksLegacyTestLoaded;
+        fs.rmSync( tmpDir, { recursive: true, force: true } );
+      }
+    } );
   } );
 } );