fix(test): mount conventional providers for rendered scripts after the G1 rebase

- prepareScriptRenderHost mounts src/providers/* with the script invocation
  and a fresh process identity per run, as the generated scripts/<name>.mjs
  render worker does; context.providers substitutes a fixture map
- a plain script opens no request scope and now rejects any context
- the fixture's tooling-summary rendered script joins the script inventory
- the test registry is version 5: main's 4 added providerLoaders, this
  lane adds manifest.scripts

Author: ScriptedAlchemy

.changeset/script-dispatch-and-workbench-surface.md

@@ -3,4 +3,4 @@
 "create-agent-bundle": patch
 ---
 
-Add `runScript`, `scriptJson`, `scriptNdjson`, and `inspectWorkbenchSurface` to `agent-bundle/test`, and move the `cli-tool` template onto the routed CLI. `runScript` (the `script-dispatch` proof level) runs a conventional `src/scripts/*` module through its generated executable's contract: a rendered `.tsx` script through the rendered-script shell with piped Markdown, TTY, `--json`, and `--ndjson` output, a plain `.ts` script as a Node process of its own with the `main` envelope, `process.exit`, exit code, stdout, stderr, optional `stdin`, and the compiled `agent-bundle/meta` identity (no `AB4760` outside a compiled surface); `testManifest().scripts` lists only the compiled scripts that ship — a nested (`AB4808`) or configuration-conflicting (`AB4809`) conventional script is never a `runScript` target — and every failure names the script route, execution form, and proof level. `inspectWorkbenchSurface` (the `workbench-surface` proof level) returns the route manifest, grouped route catalog, state declaration, lifecycle-replay fixtures, and page availability the Workbench would show for a project, without a browser or dev server, and reports `manifest-unavailable` with the compiler's error diagnostics (for example `AB4100`) for a project the compiler rejects. `ScriptRouteProps` types rendered script components. `create-agent-bundle`'s `cli-tool` template replaces the hand-written `src/cli.ts` with a routed `src/cli/greet.ts` command and a conventional `src/scripts/hello.ts`, proved by a generated projection pool at the `cli-dispatch` and `script-dispatch` levels. (#398)
+Add `runScript`, `scriptJson`, `scriptNdjson`, and `inspectWorkbenchSurface` to `agent-bundle/test`, and move the `cli-tool` template onto the routed CLI. `runScript` (the `script-dispatch` proof level) runs a conventional `src/scripts/*` module through its generated executable's contract: a rendered `.tsx` script through the rendered-script shell with piped Markdown, TTY, `--json`, and `--ndjson` output and the project's conventional `src/providers/*` mounted with the `script` invocation, a plain `.ts` script as a Node process of its own with the `main` envelope, `process.exit`, exit code, stdout, stderr, optional `stdin`, and the compiled `agent-bundle/meta` identity (no `AB4760` outside a compiled surface); `testManifest().scripts` lists only the compiled scripts that ship — a nested (`AB4808`) or configuration-conflicting (`AB4809`) conventional script is never a `runScript` target — and every failure names the script route, execution form, and proof level. `inspectWorkbenchSurface` (the `workbench-surface` proof level) returns the route manifest, grouped route catalog, state declaration, lifecycle-replay fixtures, and page availability the Workbench would show for a project, without a browser or dev server, and reports `manifest-unavailable` with the compiler's error diagnostics (for example `AB4100`) for a project the compiler rejects. `ScriptRouteProps` types rendered script components. `create-agent-bundle`'s `cli-tool` template replaces the hand-written `src/cli.ts` with a routed `src/cli/greet.ts` command and a conventional `src/scripts/hello.ts`, proved by a generated projection pool at the `cli-dispatch` and `script-dispatch` levels. (#398)

packages/agent-bundle/README.md

@@ -420,13 +420,15 @@ kind, and the module provenance.
 Conventional request context providers (`src/providers/*`, see
 [entry conventions](../../docs/entry-conventions.md#request-context-providers-power-tier))
 are mounted automatically for every manifest-backed helper — `renderRoute`,
-`renderRouteEvents`, `invokeCli`, and the in-memory MCP helpers — exactly as the
+`renderRouteEvents`, `invokeCli`, `runScript` (rendered scripts), and the
+in-memory MCP helpers — exactly as the
 generated request scopes mount them: discovered from the compiled manifest,
 executed once per request in the same deterministic key order, handed the same
 surface-specific `invocation` (`tool`, `event`, `cli`, `script`), and failing the
 request closed when a factory throws. `providers.processLifetime` is scoped the
-way the artifact scopes it: each `invokeCli` call and each `renderRoute` render
-is a fresh simulated executable (hit 1, new `instanceId`), while one open
+way the artifact scopes it: each `invokeCli` call, each `runScript` run, and
+each `renderRoute` render is a fresh simulated executable (hit 1, new
+`instanceId`), while one open
 `openInMemoryMcpServer` session shares a single identity across every request
 it handles, like the artifact's warm Flight worker. Pass `context.providers` to opt out: an explicit map is mounted
 verbatim and no conventional provider runs, which is how a test stubs a provider
@@ -548,10 +550,11 @@ Node's own type transform, lowers the `.tsx` and `.jsx` helpers a plain
 script imports with the bundler's SWC — the same lowering the generated
 executable was built with — and serves `agent-bundle/meta` as the identity the build stamps from the
 manifest's `plugin`. Explicit `scripts:` configuration entries are bundled
-entries rather than routes and stay with the packed level. As with every
-harness call, `context` (with its provider fixtures) becomes mandatory once
-the project declares providers; a plain script accepts the fixtures and no
-other request-scope override. `stdin` pipes input to a plain script (omitted,
+entries rather than routes and stay with the packed level. A rendered script
+mounts the project's conventional providers with the `script` invocation the
+generated executable passes (`context.providers` substitutes a fixture map, as
+everywhere); a plain script opens no request scope, so it accepts no `context`
+at all. `stdin` pipes input to a plain script (omitted,
 it reads end-of-file at once); `process.execArgv` is empty as under plain
 `node`; an aborted `signal` sends SIGTERM and, should the script trap it,
 kills the process after a one-second grace before the run rejects. A rendered

packages/agent-bundle/src/test/render.ts

@@ -812,6 +812,8 @@ export interface PrepareScriptRenderHostOptions {
   readonly name: string;
   /** Receives the completed document's value, exactly what the rendered-script shell validated. */
   readonly onComplete: (value: unknown) => void;
+  /** The script executable's process identity; a generated `scripts/<name>.mjs` is a fresh process per run. */
+  readonly processLifetime: ProviderProcessLifetime;
   readonly provenance: RenderedRouteProvenance;
   readonly signal: AbortSignal;
 }
@@ -895,8 +897,18 @@ export const prepareScriptRenderHost = async (
         componentProps: (request) => ({ argv, signal: request.signal }),
         contextProgress: context.progress,
         renderer,
-        requestInit: (request) => {
+        requestInit: async (request) => {
           const root = process.cwd();
+          // The generated script's render worker hands its providers the
+          // `script` invocation with the path-derived name, never the route id.
+          const providers = await mountProviders({
+            explicit: context.providers,
+            invocation,
+            manifest: options.manifest,
+            processHit: claimProcessHit(options.processLifetime),
+            provenance: options.provenance,
+            signal: request.signal,
+          });
           return {
             capabilities: {
               command: renderer.unavailable(),
@@ -908,6 +920,7 @@ export const prepareScriptRenderHost = async (
             workspace: renderer.available({ root }, 'derived'),
             ...context,
             ...state.context,
+            providers,
             invocation: {
               kind: 'script',
               operationId: options.provenance.routeId,

packages/agent-bundle/src/test/script.ts

@@ -32,6 +32,7 @@ import { metaModuleSpecifier } from '../build/meta.ts';
 import { runGeneratedRenderedScript } from '../cli-entry.ts';
 import type { CliRenderedEvent } from '../cli-entry.ts';
 import { testMetaModuleSource } from '../rstest/meta-module.ts';
+import { createProviderProcessLifetime } from '../routes/provider-execution.ts';
 import { AgentTestError, captured } from './errors.ts';
 import {
   SCRIPT_DISPATCH_PROOF_LEVEL,
@@ -67,12 +68,11 @@ export interface RunScriptOptionsBase {
 
 /**
  * Run options. `context` carries the request-scope overrides for a rendered
- * script over the runtime's request contract and is required once the project
- * declares providers (see {@link RenderRouteContextInit}): the generated
- * executable mounts `src/providers/*` before the component renders, and the
- * harness installs the fixtures instead. A plain script has no request scope;
- * it accepts the provider fixtures the contract demands and nothing else of
- * `context`.
+ * script over the runtime's request contract (see {@link RenderRouteContextInit}):
+ * omitted, the harness mounts the project's `src/providers/*` with the
+ * `script` invocation exactly as the generated executable does before the
+ * component renders, and `context.providers` substitutes a fixture map. A
+ * plain script has no request scope and accepts no `context`.
  */
 export type RunScriptOptions = RunScriptOptionsBase & RenderRouteContextInit;
 
@@ -403,12 +403,10 @@ const rejectRenderedOnlyOptions = (
   script: TestableScriptDescriptor,
   options: RunScriptOptions,
 ): void => {
-  // Provider fixtures are what the options contract demands of every call in
-  // a project that declares providers; a plain script cannot use them, but
-  // supplying them is not a mistake. Any other request-scope override is.
-  const contextOverrides = Object.keys(options.context ?? {}).filter((key) => key !== 'providers');
+  // A plain script opens no request scope: no providers are mounted for it,
+  // so there is nothing for `context` — fixtures included — to override.
   const offending = [
-    ...(contextOverrides.length === 0 ? [] : ['context']),
+    ...(options.context === undefined ? [] : ['context']),
     ...(options.tty === undefined ? [] : ['tty']),
   ];
   if (offending.length === 0) return;
@@ -567,6 +565,9 @@ export const runScript = async (
     manifest,
     name: script.name,
     onComplete: (completed) => { value = completed; },
+    // Each generated `scripts/<name>.mjs` is a process of its own: its
+    // providers see hit 1 of a fresh identity on every run.
+    processLifetime: createProviderProcessLifetime(),
     provenance,
     signal,
   });

packages/agent-bundle/tests/projection/script-dispatch.test.ts

@@ -30,6 +30,7 @@ describe('the compiled script inventory', () => {
       ['identity', false],
       ['stalled', true],
       ['summary', true],
+      ['tooling-summary', true],
     ]);
   });
 
@@ -38,7 +39,7 @@ describe('the compiled script inventory', () => {
 
     expect(error).toBeInstanceOf(AgentTestError);
     expect((error as AgentTestError).code).toBe('script-not-found');
-    expect((error as AgentTestError).message).toContain('compiled:     badge, banner, blank, broken, checksum, constant, identity, stalled, summary');
+    expect((error as AgentTestError).message).toContain('compiled:     badge, banner, blank, broken, checksum, constant, identity, stalled, summary, tooling-summary');
     expect((error as AgentTestError).message).toContain(`project root: ${testManifest().projectRoot}`);
   });
 });
@@ -82,7 +83,7 @@ describe('rendered scripts at the script dispatch level', () => {
     expect(run).toMatchObject({
       kind: 'rendered',
       name: 'summary',
-      provenance: { execution: 'rendered-shell', proofLevel: 'script-dispatch', scripts: ['badge', 'banner', 'blank', 'broken', 'checksum', 'constant', 'identity', 'stalled', 'summary'] },
+      provenance: { execution: 'rendered-shell', proofLevel: 'script-dispatch', scripts: ['badge', 'banner', 'blank', 'broken', 'checksum', 'constant', 'identity', 'stalled', 'summary', 'tooling-summary'] },
       routeId: 'script:summary',
     });
   });
@@ -177,6 +178,32 @@ describe('rendered scripts at the script dispatch level', () => {
     expect(run.value).toBeUndefined();
   }, 5000);
 
+  it('mounts the conventional providers for a rendered script with the script invocation, as the generated executable does', async () => {
+    type Summary = { arguments: number; keys: string[]; libraryTooling: unknown };
+    const first = await runScript('tooling-summary', ['--json', 'a.mp4', '--fast']);
+    const second = await runScript('tooling-summary', ['--json', 'b.mp4']);
+
+    expect(first.exitCode).toBe(0);
+    // The generated script passes `name: 'tooling-summary'`, never the route id.
+    expect(scriptJson(first)).toEqual({
+      arguments: 2,
+      keys: ['libraryTooling', 'processLifetime'],
+      libraryTooling: { kind: 'script', surface: 'tooling-summary', tool: 'ffprobe 6.1' },
+    });
+    expect((scriptJson(second) as Summary).arguments).toBe(1);
+
+    // An explicit fixture map is mounted verbatim: nothing under
+    // src/providers/ runs for this invocation.
+    const stubbed = await runScript('tooling-summary', ['--json', 'c.mp4'], {
+      context: { providers: { libraryTooling: { tool: 'stub' }, processLifetime: { hits: 7, instanceId: 'fixture', pid: 0 } } },
+    });
+    expect(scriptJson(stubbed)).toEqual({
+      arguments: 1,
+      keys: ['libraryTooling', 'processLifetime'],
+      libraryTooling: { tool: 'stub' },
+    });
+  });
+
   it('rejects conflicting output flags at the shell boundary', async () => {
     const run = await runScript('summary', ['--json', '--ndjson']);
 
@@ -372,12 +399,8 @@ describe('plain scripts at the script dispatch level', () => {
     expect(modelless.stderr).toContain('produced no plugin model');
   });
 
-  it('accepts provider fixtures on a plain script, as the options contract may demand them, and nothing else of context', async () => {
-    const withProviders = await runScript('checksum', ['ab'], { context: { providers: {} } });
-    expect(withProviders.exitCode).toBe(0);
-    expect(withProviders.stdout).toBe('Fixture checksum: 2\n');
-
-    const error = await runScript('checksum', ['ab'], { context: { providers: {}, invocation: { surface: 'x' } } })
+  it('rejects context on a plain script: it opens no request scope, so no providers are mounted for it', async () => {
+    const error = await runScript('checksum', ['ab'], { context: { providers: {} } })
       .catch((thrown: unknown) => thrown);
     expect(error).toBeInstanceOf(AgentTestError);
     expect((error as AgentTestError).code).toBe('invalid-input');

packages/agent-bundle/tests/test-harness-manifest.test.ts

@@ -190,6 +190,13 @@ describe('the compiled test manifest', () => {
         routeId: 'script:summary',
         source: resolve(fixtureRoot, 'src/scripts/summary.tsx'),
       },
+      {
+        name: 'tooling-summary',
+        relativePath: 'src/scripts/tooling-summary.tsx',
+        rendered: true,
+        routeId: 'script:tooling-summary',
+        source: resolve(fixtureRoot, 'src/scripts/tooling-summary.tsx'),
+      },
     ]);
     expect(manifest.apps).toEqual({
       panel: {
@@ -390,8 +397,8 @@ describe('the compiled test manifest', () => {
     // `banner` is claimed by configuration (AB4809) and `release/verify` is
     // nested (AB4808): neither becomes a scripts/<name>.mjs executable, so
     // neither is a script-dispatch target.
-    expect(projected.scripts.map((script) => script.name)).toEqual(['badge', 'blank', 'broken', 'checksum', 'constant', 'identity', 'stalled', 'summary']);
-    expect(manifest.scripts.map((script) => script.name)).toEqual(['badge', 'banner', 'blank', 'broken', 'checksum', 'constant', 'identity', 'stalled', 'summary']);
+    expect(projected.scripts.map((script) => script.name)).toEqual(['badge', 'blank', 'broken', 'checksum', 'constant', 'identity', 'stalled', 'summary', 'tooling-summary']);
+    expect(manifest.scripts.map((script) => script.name)).toEqual(['badge', 'banner', 'blank', 'broken', 'checksum', 'constant', 'identity', 'stalled', 'summary', 'tooling-summary']);
   });
 
   it('rejects a shared app name whose compile-relevant declaration differs', async () => {