@shipfox/api-definitions 11.0.0 → 12.2.0

package/src/core/workflow-model/normalize-workflow-document.test.ts

@@ -69,16 +69,219 @@ const integrationValidationContext = {
         ],
       },
     ],
+    [
+      'jira',
+      {
+        selectors: [
+          {token: 'get_issue', kind: 'standalone', sensitivity: 'read', sensitive: false},
+          {token: 'add_comment', kind: 'standalone', sensitivity: 'write', sensitive: false},
+        ],
+      },
+    ],
   ]),
   workspaceConnectionSnapshot: new Map([
     ['github-main', {id: 'conn_1', provider: 'github', capabilities: ['agent_tools']}],
     ['sentry-main', {id: 'conn_2', provider: 'sentry', capabilities: []}],
     ['linear-main', {id: 'conn_3', provider: 'linear', capabilities: ['agent_tools']}],
+    ['jira-main', {id: 'conn_4', provider: 'jira', capabilities: ['agent_tools']}],
   ]),
   defaultConnectionSlug: 'github-main',
 } satisfies IntegrationValidationContext;
 
 describe('normalizeWorkflowDocument', () => {
+  it('rejects interpolated workflow names in favor of run_name', () => {
+    const error = expectInvalid({
+      name: interpolation('inputs.environment'),
+      jobs: {build: {steps: [{run: 'build'}]}},
+    });
+
+    expect(error.issues).toEqual([
+      expect.objectContaining({
+        code: 'invalid-interpolation-template',
+        message: 'Workflow name must be literal. Move runtime interpolation to run_name.',
+        path: ['name'],
+      }),
+    ]);
+  });
+
+  it('rejects unterminated workflow-name templates with the migration guidance', () => {
+    const error = expectInvalid({
+      name: '$' + '{{ unterminated',
+      jobs: {build: {steps: [{run: 'build'}]}},
+    });
+
+    expect(error.issues).toEqual([
+      expect.objectContaining({
+        code: 'invalid-interpolation-template',
+        message: 'Workflow name must be literal. Move runtime interpolation to run_name.',
+        path: ['name'],
+        details: expect.objectContaining({reason: 'unterminated opener'}),
+      }),
+    ]);
+  });
+
+  it('rejects unterminated job-name templates with the migration guidance', () => {
+    const error = expectInvalid({
+      name: 'Deploy',
+      jobs: {
+        build: {name: '$' + '{{ unterminated', steps: [{run: 'build'}]},
+      },
+    });
+
+    expect(error.issues).toEqual([
+      expect.objectContaining({
+        code: 'invalid-interpolation-template',
+        message: 'Job name must be literal. Move runtime interpolation to execution_name.',
+        path: ['jobs', 'build', 'name'],
+        details: expect.objectContaining({reason: 'unterminated opener'}),
+      }),
+    ]);
+  });
+
+  it('normalizes workflow run and job execution name templates', () => {
+    const model = normalizeWorkflowDocument({
+      name: 'Deploy application',
+      run_name: `Deploy ${interpolation('inputs.environment')}`,
+      jobs: {
+        deploy: {
+          name: 'Deploy',
+          execution_name: `Deploy ${interpolation('event.environment')}`,
+          steps: [{run: 'deploy'}],
+        },
+      },
+    });
+
+    expect(model.runName).toMatchObject([
+      {kind: 'literal', value: 'Deploy '},
+      {kind: 'deferred', roots: ['inputs'], fillTarget: 'run-creation'},
+    ]);
+    expect(model.jobs[0]?.executionName).toMatchObject([
+      {kind: 'literal', value: 'Deploy '},
+      {kind: 'deferred', roots: ['event'], fillTarget: 'execution-creation'},
+    ]);
+  });
+
+  it('preserves literal workflow run and job execution names', () => {
+    const model = normalizeWorkflowDocument({
+      name: 'Workflow',
+      run_name: 'Static run name',
+      jobs: {
+        build: {
+          execution_name: 'Static execution name',
+          steps: [{run: 'build'}],
+        },
+      },
+    });
+
+    expect(model.runName).toEqual([{kind: 'literal', value: 'Static run name'}]);
+    expect(model.jobs[0]?.executionName).toEqual([
+      {kind: 'literal', value: 'Static execution name'},
+    ]);
+  });
+
+  it('unescapes literal workflow and job names', () => {
+    const escapedName = `$${interpolation('inputs.environment')}`;
+    const model = normalizeWorkflowDocument({
+      name: escapedName,
+      jobs: {
+        build: {name: escapedName, steps: [{run: 'build'}]},
+      },
+    });
+
+    expect(model.name).toBe(interpolation('inputs.environment'));
+    expect(model.jobs[0]?.name).toBe(interpolation('inputs.environment'));
+  });
+
+  it.each([
+    [
+      'run_name',
+      {
+        name: 'Workflow',
+        run_name: interpolation('steps.build.outputs.name'),
+        jobs: {build: {steps: [{run: 'build'}]}},
+      },
+    ],
+    [
+      'execution_name',
+      {
+        name: 'Workflow',
+        jobs: {
+          build: {
+            execution_name: interpolation('steps.build.outputs.name'),
+            steps: [{run: 'build'}],
+          },
+        },
+      },
+    ],
+  ] as const)('rejects unavailable context in %s', (_field, document) => {
+    const error = expectInvalid(document as unknown as WorkflowDocument);
+    expect(error.issues).toEqual([
+      expect.objectContaining({code: 'context-unavailable-at-fill-site'}),
+    ]);
+  });
+
+  it('allows computed access to unrelated dynamic-name context fields', () => {
+    const model = normalizeWorkflowDocument({
+      name: 'Workflow',
+      run_name: interpolation('run["id"]'),
+      jobs: {
+        build: {
+          execution_name: interpolation('execution["status"]'),
+          steps: [{run: 'build'}],
+        },
+      },
+    });
+
+    expect(model.runName).toMatchObject([{kind: 'deferred', roots: ['run']}]);
+    expect(model.jobs[0]?.executionName).toMatchObject([{kind: 'deferred', roots: ['execution']}]);
+  });
+
+  it.each([
+    [
+      'run_name',
+      {
+        name: 'Workflow',
+        run_name: interpolation('run.name'),
+        jobs: {build: {steps: [{run: 'build'}]}},
+      },
+    ],
+    [
+      'run_name bracket access',
+      {
+        name: 'Workflow',
+        run_name: interpolation('run["name"]'),
+        jobs: {build: {steps: [{run: 'build'}]}},
+      },
+    ],
+    [
+      'execution_name',
+      {
+        name: 'Workflow',
+        jobs: {
+          build: {
+            execution_name: interpolation('execution.name'),
+            steps: [{run: 'build'}],
+          },
+        },
+      },
+    ],
+    [
+      'execution_name bracket access',
+      {
+        name: 'Workflow',
+        jobs: {
+          build: {
+            execution_name: interpolation('execution["name"]'),
+            steps: [{run: 'build'}],
+          },
+        },
+      },
+    ],
+  ] as const)('rejects dynamic-name self-reference in %s', (_field, document) => {
+    const error = expectInvalid(document as unknown as WorkflowDocument);
+    expect(error.issues).toEqual([expect.objectContaining({code: 'dynamic-name-self-reference'})]);
+  });
+
   it('normalizes a workflow document into a WorkflowModel', () => {
     const document: WorkflowDocument = {
       name: 'simple build',
@@ -154,7 +357,7 @@ describe('normalizeWorkflowDocument', () => {
             {
               key: 'review',
               harness: 'claude',
-              model: 'gpt-5.5-pro',
+              model: 'claude-opus-4-8',
               provider: 'anthropic',
               prompt: 'Review the fix.',
               thinking: 'low',
@@ -454,6 +657,56 @@ describe('normalizeWorkflowDocument', () => {
     });
   });
 
+  it('requires allow_write for Jira write tools', () => {
+    const document: WorkflowDocument = {
+      name: 'jira write integrations',
+      jobs: {
+        fix: {
+          steps: [
+            {
+              prompt: 'Comment on the issue.',
+              integrations: [{connection: 'jira-main', include: ['add_comment']}],
+            },
+          ],
+        },
+      },
+    };
+
+    const error = expectInvalid(document, {integrationValidationContext});
+
+    expect(error.issues).toMatchObject([
+      {
+        code: 'integration-write-not-allowed',
+        details: {tokens: ['add_comment']},
+      },
+    ]);
+  });
+
+  it('accepts Jira write tools when allow_write is true', () => {
+    const document: WorkflowDocument = {
+      name: 'jira write integrations',
+      jobs: {
+        fix: {
+          steps: [
+            {
+              prompt: 'Comment on the issue.',
+              integrations: [
+                {connection: 'jira-main', include: ['add_comment'], allow_write: true},
+              ],
+            },
+          ],
+        },
+      },
+    };
+
+    const model = normalizeWorkflowDocument(document, {integrationValidationContext});
+
+    expect(model.jobs[0]?.steps[0]).toMatchObject({
+      kind: 'agent',
+      integrations: [{connection: 'jira-main', include: ['add_comment'], allowWrite: true}],
+    });
+  });
+
   it('reports connection failures before token checks', () => {
     const document: WorkflowDocument = {
       name: 'missing connection',
@@ -538,6 +791,7 @@ describe('normalizeWorkflowDocument', () => {
             {
               harness: 'pi',
               provider: 'workspace-openai-compatible',
+              model: 'workspace-model',
               prompt: 'Fix it.',
             },
           ],
@@ -551,6 +805,80 @@ describe('normalizeWorkflowDocument', () => {
       kind: 'agent',
       harness: 'pi',
       provider: 'workspace-openai-compatible',
+      model: 'workspace-model',
+    });
+  });
+
+  it('reports unsupported literal models', () => {
+    const document: WorkflowDocument = {
+      name: 'agent build',
+      jobs: {
+        fix: {
+          steps: [{harness: 'pi', provider: 'anthropic', model: 'not-a-model', prompt: 'Fix it.'}],
+        },
+      },
+    };
+
+    const error = expectInvalid(document);
+
+    expect(error.issues).toEqual([
+      {
+        code: 'invalid-model',
+        message:
+          'Agent model "not-a-model" is not available for harness "pi" and provider "anthropic".',
+        path: ['jobs', 'fix', 'steps', 0, 'model'],
+        details: {harness: 'pi', provider: 'anthropic', model: 'not-a-model'},
+      },
+    ]);
+  });
+
+  it('allows custom providers without an explicit harness', () => {
+    const document: WorkflowDocument = {
+      name: 'agent build',
+      jobs: {
+        fix: {
+          steps: [
+            {
+              provider: 'workspace-openai-compatible',
+              model: 'workspace-model',
+              prompt: 'Fix it.',
+            },
+          ],
+        },
+      },
+    };
+
+    const model = normalizeWorkflowDocument(document);
+
+    expect(model.jobs[0]?.steps[0]).toMatchObject({
+      kind: 'agent',
+      provider: 'workspace-openai-compatible',
+      model: 'workspace-model',
+    });
+  });
+
+  it('defers harness-specific validation when harness is omitted', () => {
+    const document: WorkflowDocument = {
+      name: 'workspace-default harness',
+      jobs: {
+        fix: {
+          steps: [
+            {
+              provider: 'anthropic',
+              model: 'claude-sonnet-4-6',
+              prompt: 'Fix it.',
+            },
+          ],
+        },
+      },
+    };
+
+    const model = normalizeWorkflowDocument(document);
+
+    expect(model.jobs[0]?.steps[0]).toMatchObject({
+      kind: 'agent',
+      provider: 'anthropic',
+      model: 'claude-sonnet-4-6',
     });
   });
 
@@ -743,6 +1071,29 @@ describe('normalizeWorkflowDocument', () => {
     });
   });
 
+  it('defers an interpolated thinking level to dispatch', () => {
+    const document: WorkflowDocument = {
+      name: 'agent build',
+      jobs: {
+        fix: {
+          steps: [
+            {
+              harness: 'claude',
+              prompt: 'Fix it.',
+              thinking: workflowInterpolation('vars.THINKING'),
+            },
+          ],
+        },
+      },
+    };
+
+    const model = normalizeWorkflowDocument(document);
+    const step = model.jobs[0]?.steps[0];
+
+    if (step?.kind !== 'agent') throw new Error('Expected an agent step');
+    expect(step.templates?.thinking).toMatchObject([{kind: 'deferred', roots: ['vars']}]);
+  });
+
   it('normalizes job success expressions and execution timeouts', () => {
     const document: WorkflowDocument = {
       name: 'job controls',
@@ -831,6 +1182,144 @@ describe('normalizeWorkflowDocument', () => {
     expect(model.jobs[0]?.checkout).toEqual(DEFAULT_JOB_CHECKOUT);
   });
 
+  it('preserves the job checkout opt-out in the model', () => {
+    const model = normalizeWorkflowDocument({
+      name: 'checkout disabled',
+      jobs: {
+        build: {
+          checkout: false,
+          steps: [{run: 'npm test'}],
+        },
+      },
+    });
+
+    expect(model.jobs[0]?.checkout).toBe(false);
+  });
+
+  it('normalizes checkout-step targets from earlier step outputs', () => {
+    const model = normalizeWorkflowDocument({
+      name: 'templated checkout step',
+      jobs: {
+        build: {
+          steps: [
+            {
+              key: 'route',
+              run: 'echo route',
+              outputs: {
+                connection: {type: 'string'},
+                repository: {type: 'string'},
+                ref: {type: 'string'},
+                path: {type: 'string'},
+              },
+            },
+            {
+              key: 'checkout',
+              checkout: {
+                connection: interpolation('inputs.connection'),
+                repository: interpolation('steps.route.outputs.repository'),
+                ref: interpolation('steps.route.outputs.ref'),
+                path: interpolation('steps.route.outputs.path'),
+              },
+            },
+          ],
+        },
+      },
+    });
+
+    expect(model.jobs[0]?.steps[1]).toMatchObject({
+      kind: 'checkout',
+      checkout: {
+        connection: interpolation('inputs.connection'),
+        repository: interpolation('steps.route.outputs.repository'),
+        ref: interpolation('steps.route.outputs.ref'),
+        path: interpolation('steps.route.outputs.path'),
+        fetchDepth: 1,
+        permissions: {contents: 'read'},
+        persistCredentials: true,
+        templates: {
+          connection: [{kind: 'deferred', roots: ['inputs'], fillTarget: 'run-creation'}],
+          repository: [{kind: 'deferred', roots: ['steps'], fillTarget: 'step-dispatch'}],
+          ref: [{kind: 'deferred', roots: ['steps'], fillTarget: 'step-dispatch'}],
+          path: [{kind: 'deferred', roots: ['steps'], fillTarget: 'step-dispatch'}],
+        },
+      },
+    });
+  });
+
+  it('reports invalid checkout target combinations from model normalization', () => {
+    const error = expectInvalid({
+      name: 'invalid checkout target',
+      jobs: {
+        build: {
+          steps: [{checkout: {project: 'project-id', repository: 'acme/api'}}],
+        },
+      },
+    });
+
+    expect(error.issues).toContainEqual(
+      expect.objectContaining({
+        code: 'checkout-target-invalid',
+        path: ['jobs', 'build', 'steps', 0, 'checkout', 'repository'],
+      }),
+    );
+
+    const missingRepository = expectInvalid({
+      name: 'missing checkout repository',
+      jobs: {
+        build: {
+          steps: [{checkout: {connection: 'github'}}],
+        },
+      },
+    });
+
+    expect(missingRepository.issues).toContainEqual(
+      expect.objectContaining({
+        code: 'checkout-target-invalid',
+        path: ['jobs', 'build', 'steps', 0, 'checkout', 'repository'],
+        details: {fields: ['connection', 'repository']},
+      }),
+    );
+  });
+
+  it('normalizes checkout steps and their static defaults', () => {
+    const model = normalizeWorkflowDocument({
+      name: 'checkout step',
+      jobs: {
+        build: {
+          steps: [
+            {
+              key: 'fetch-target',
+              checkout: {
+                repository: 'acme/api',
+                ref: 'refs/heads/main',
+                'fetch-depth': 0,
+                path: 'target',
+                permissions: {contents: 'write'},
+                'persist-credentials': false,
+                force: true,
+              },
+            },
+          ],
+        },
+      },
+    });
+
+    expect(model.jobs[0]?.steps[0]).toMatchObject({
+      id: expect.stringContaining('fetch-target'),
+      key: 'fetch-target',
+      kind: 'checkout',
+      checkout: {
+        repository: 'acme/api',
+        ref: 'refs/heads/main',
+        fetchDepth: 0,
+        path: 'target',
+        permissions: {contents: 'write'},
+        persistCredentials: false,
+        force: true,
+      },
+    });
+  });
+
   it('normalizes checkout contents write and defaults persisted credentials', () => {
     const document: WorkflowDocument = {
       name: 'write checkout',
@@ -880,7 +1369,7 @@ describe('normalizeWorkflowDocument', () => {
       name: 'listen for reviews',
       jobs: {
         review: {
-          name: displayName,
+          execution_name: displayName,
           listening: {
             on: [
               {
@@ -915,7 +1404,7 @@ describe('normalizeWorkflowDocument', () => {
         onResolve: 'cancel',
       },
     });
-    expect(model.jobs[0]?.name?.[1]).toMatchObject({
+    expect(model.jobs[0]?.executionName?.[1]).toMatchObject({
       kind: 'deferred',
       expression: {source: 'execution.index', check: 'typed'},
     });
@@ -968,7 +1457,7 @@ describe('normalizeWorkflowDocument', () => {
     ]);
   });
 
-  it('validates listener filters against job-activation roots', () => {
+  it('validates listener filters against their persisted snapshot roots', () => {
     const document: WorkflowDocument = {
       name: 'listener filter roots',
       jobs: {
@@ -983,7 +1472,7 @@ describe('normalizeWorkflowDocument', () => {
                 source: 'github',
                 event: 'pull_request_review',
                 filter:
-                  'run.id != "" && inputs.target == event.issue.number && job.key == "review" && executions.all(execution, execution.status != "") && matrix.os == "linux" && jobs.build.outputs.pr_number == event.issue.number',
+                  'run.id != "" && trigger.event == "pull_request_review" && inputs.target == event.issue.number && vars.ENABLED == "true" && job.key == "review" && jobs.build.outputs.pr_number == event.issue.number',
               },
             ],
             until: [
@@ -1002,7 +1491,7 @@ describe('normalizeWorkflowDocument', () => {
     const model = normalizeWorkflowDocument(document);
 
     expect(model.jobs[1]?.listening?.on[0]?.filter).toBe(
-      'run.id != "" && inputs.target == event.issue.number && job.key == "review" && executions.all(execution, execution.status != "") && matrix.os == "linux" && jobs.build.outputs.pr_number == event.issue.number',
+      'run.id != "" && trigger.event == "pull_request_review" && inputs.target == event.issue.number && vars.ENABLED == "true" && job.key == "review" && jobs.build.outputs.pr_number == event.issue.number',
     );
     expect(model.jobs[1]?.listening?.until?.[0]?.filter).toBe('event.action == "closed"');
   });
@@ -1010,6 +1499,8 @@ describe('normalizeWorkflowDocument', () => {
   it.each([
     ['step root', 'step.status == "succeeded"', 'context-unavailable-at-predicate-site'],
     ['steps root', 'steps.build.outputs.sha == "abc"', 'context-unavailable-at-predicate-site'],
+    ['executions root', 'executions.size() > 0', 'context-unavailable-at-predicate-site'],
+    ['matrix root', 'matrix.os == "linux"', 'context-unavailable-at-predicate-site'],
     ['runner root', 'runner.os == "linux"', 'runner-context-in-server-predicate'],
     ['non-boolean source', 'event.action', 'invalid-listener-filter'],
   ] as const)('reports invalid listener on filters for %s', (_label, filter, code) => {
@@ -1114,12 +1605,12 @@ describe('normalizeWorkflowDocument', () => {
     ]);
   });
 
-  it('preserves explicit model ids even when the seed catalog only knows provider defaults', () => {
+  it('accepts explicit model ids present in the harness catalog', () => {
     const document: WorkflowDocument = {
       name: 'agent build',
       jobs: {
         fix: {
-          steps: [{provider: 'openai', model: 'gpt-4.1', prompt: 'Fix it.'}],
+          steps: [{harness: 'pi', provider: 'openai', model: 'gpt-4.1', prompt: 'Fix it.'}],
         },
       },
     };
@@ -1602,7 +2093,7 @@ describe('normalizeWorkflowDocument', () => {
     });
   });
 
-  it('accepts server roots available at step reporting in gate success', () => {
+  it('rejects server roots omitted from the gate success context', () => {
     const document: WorkflowDocument = {
       name: 'server-context gate',
       jobs: {
@@ -1610,14 +2101,21 @@ describe('normalizeWorkflowDocument', () => {
       },
     };
 
-    const model = normalizeWorkflowDocument(document);
+    const error = expectInvalid(document);
 
-    expect(model.jobs[0]?.steps[0]?.gate?.success).toEqual({
-      language: 'cel',
-      source: 'run.id != ""',
-      check: 'typed',
-      resultType: 'bool',
-    });
+    expect(error.issues).toEqual([
+      expect.objectContaining({
+        code: 'context-unavailable-at-predicate-site',
+        message: expect.stringContaining('Step gate success references context "run"'),
+        path: ['jobs', 'build', 'steps', 0, 'gate', 'success'],
+        details: expect.objectContaining({
+          field: 'step.success',
+          source: 'run.id != ""',
+          unavailableRoots: ['run'],
+          site: 'step-report',
+        }),
+      }),
+    ]);
   });
 
   it('rejects runner-host roots in gate success with a server-predicate issue', () => {
@@ -1647,7 +2145,7 @@ describe('normalizeWorkflowDocument', () => {
     ]);
   });
 
-  it('rejects vars in gate success with a server-predicate issue', () => {
+  it('accepts vars in gate success', () => {
     const document: WorkflowDocument = {
       name: 'vars-context gate',
       jobs: {
@@ -1657,24 +2155,15 @@ describe('normalizeWorkflowDocument', () => {
       },
     };
 
-    const error = expectInvalid(document);
+    const model = normalizeWorkflowDocument(document);
 
-    expect(error.issues).toEqual([
-      expect.objectContaining({
-        code: 'vars-context-in-server-predicate',
-        message: expect.stringContaining('cannot reference vars'),
-        path: ['jobs', 'build', 'steps', 0, 'gate', 'success'],
-        details: expect.objectContaining({
-          field: 'step.success',
-          source: 'vars.REQUIRED == "true"',
-          rejectedRoots: ['vars'],
-          site: 'step-report',
-        }),
-      }),
-    ]);
+    expect(model.jobs[0]?.steps[0]?.gate?.success).toMatchObject({
+      source: 'vars.REQUIRED == "true"',
+      check: 'syntax',
+    });
   });
 
-  it('accepts jobs root references at the gate predicate site', () => {
+  it('rejects jobs root references omitted from the gate success context', () => {
     const document: WorkflowDocument = {
       name: 'jobs-context gate',
       jobs: {
@@ -1688,13 +2177,21 @@ describe('normalizeWorkflowDocument', () => {
       },
     };
 
-    const model = normalizeWorkflowDocument(document);
+    const error = expectInvalid(document);
 
-    expect(model.jobs[1]?.steps[0]?.gate?.success).toEqual({
-      language: 'cel',
-      source: 'jobs.build.status == "succeeded"',
-      check: 'syntax',
-    });
+    expect(error.issues).toEqual([
+      expect.objectContaining({
+        code: 'context-unavailable-at-predicate-site',
+        message: expect.stringContaining('Step gate success references context "jobs"'),
+        path: ['jobs', 'deploy', 'steps', 0, 'gate', 'success'],
+        details: expect.objectContaining({
+          field: 'step.success',
+          source: 'jobs.build.status == "succeeded"',
+          unavailableRoots: ['jobs'],
+          site: 'step-report',
+        }),
+      }),
+    ]);
   });
 
   it('parses job output mappings at execution resolution', () => {
@@ -1981,7 +2478,7 @@ describe('normalizeWorkflowDocument', () => {
     });
   });
 
-  it('rejects untrusted step outputs in trusted-only run fields', () => {
+  it('allows step outputs in run fields', () => {
     const document: WorkflowDocument = {
       name: 'untrusted step output',
       jobs: {
@@ -1994,15 +2491,17 @@ describe('normalizeWorkflowDocument', () => {
       },
     };
 
-    const error = expectInvalid(document);
+    const model = normalizeWorkflowDocument(document);
 
-    expect(error.issues).toEqual([
-      expect.objectContaining({
-        code: 'untrusted-context-in-field',
-        path: ['jobs', 'build', 'steps', 1, 'run'],
-        details: expect.objectContaining({field: 'run', rejectedRoots: ['steps']}),
-      }),
-    ]);
+    expect(model.jobs[0]?.steps[1]).toMatchObject({
+      kind: 'run',
+      templates: {
+        command: [
+          {kind: 'literal', value: 'echo '},
+          {kind: 'deferred', roots: ['steps']},
+        ],
+      },
+    });
   });
 
   it('infers typed job output scalars for downstream job overlays', () => {
@@ -2119,9 +2618,9 @@ describe('normalizeWorkflowDocument', () => {
     });
   });
 
-  it('reports non-scalar typed job output mappings', () => {
+  it('infers structured typed job output mappings', () => {
     const document: WorkflowDocument = {
-      name: 'bad job output type',
+      name: 'structured job output type',
       jobs: {
         build: {
           steps: [
@@ -2132,10 +2631,13 @@ describe('normalizeWorkflowDocument', () => {
                 metadata: {
                   type: 'json',
                   schema: {
-                    type: 'object',
-                    additionalProperties: false,
-                    required: ['digest'],
-                    properties: {digest: {type: 'string'}},
+                    type: 'array',
+                    items: {
+                      type: 'object',
+                      additionalProperties: false,
+                      required: ['severity'],
+                      properties: {severity: {type: 'string'}},
+                    },
                   },
                 },
               },
@@ -2144,18 +2646,82 @@ describe('normalizeWorkflowDocument', () => {
           outputs: {
             metadata: interpolation('steps.collect.outputs.metadata'),
           },
-        },
+        },
+      },
+    };
+
+    const model = normalizeWorkflowDocument(document);
+
+    expect(model.jobs[0]?.outputTypes).toEqual({
+      metadata: {
+        kind: 'list',
+        element: {
+          kind: 'object',
+          fields: {severity: 'string'},
+        },
+      },
+    });
+  });
+
+  it('authorizes indexed reads from structured job outputs', () => {
+    const document: WorkflowDocument = {
+      name: 'indexed structured job output',
+      jobs: {
+        review: {
+          steps: [
+            {
+              key: 'inspect',
+              run: 'npm run inspect',
+              outputs: {
+                findings: {
+                  type: 'json',
+                  schema: {
+                    type: 'array',
+                    items: {
+                      type: 'object',
+                      additionalProperties: false,
+                      required: ['severity'],
+                      properties: {severity: {type: 'string'}},
+                    },
+                  },
+                },
+              },
+            },
+          ],
+          outputs: {
+            findings: interpolation('steps.inspect.outputs.findings'),
+          },
+        },
+        summarize: {
+          needs: ['review'],
+          steps: [
+            {
+              run: `printf '%s\\n' ${interpolation('jobs.review.outputs.findings[0].severity')}`,
+            },
+          ],
+        },
+      },
+    };
+
+    const model = normalizeWorkflowDocument(document);
+    const summarize = model.jobs.find((job) => job.key === 'summarize');
+
+    expect(summarize?.steps[0]).toMatchObject({
+      kind: 'run',
+      templates: {
+        command: [
+          {kind: 'literal', value: "printf '%s\\n' "},
+          {
+            kind: 'deferred',
+            expression: {
+              source: 'jobs.review.outputs.findings[0].severity',
+              check: 'typed',
+            },
+            roots: ['jobs'],
+          },
+        ],
       },
-    };
-
-    const error = expectInvalid(document);
-
-    expect(error.issues).toEqual([
-      expect.objectContaining({
-        code: 'invalid-job-output',
-        path: ['jobs', 'build', 'outputs', 'metadata'],
-      }),
-    ]);
+    });
   });
 
   it('rejects job output references without a direct needs edge', () => {
@@ -2318,29 +2884,29 @@ describe('normalizeWorkflowDocument', () => {
     );
   });
 
-  it('rejects vars roots in if predicates', () => {
+  it('accepts vars in job and step if predicates', () => {
     const document: WorkflowDocument = {
       name: 'vars condition',
       jobs: {
         build: {
           if: interpolation('vars.REQUIRED == "true"'),
-          steps: [{run: 'npm run build'}],
+          steps: [{if: interpolation('vars.REQUIRED == "true"'), run: 'npm run build'}],
         },
       },
     };
 
-    const error = expectInvalid(document);
+    const model = normalizeWorkflowDocument(document);
 
-    expect(error.issues).toEqual([
-      expect.objectContaining({
-        code: 'vars-context-in-server-predicate',
-        path: ['jobs', 'build', 'if'],
-        details: expect.objectContaining({
-          field: 'job.if',
-          rejectedRoots: ['vars'],
-        }),
-      }),
-    ]);
+    expect(model.jobs[0]?.if).toMatchObject({
+      source: 'vars.REQUIRED == "true"',
+      check: 'typed',
+      resultType: 'bool',
+    });
+    expect(model.jobs[0]?.steps[0]?.if).toMatchObject({
+      source: 'vars.REQUIRED == "true"',
+      check: 'typed',
+      resultType: 'bool',
+    });
   });
 
   it('rejects if job references without a direct needs edge', () => {
@@ -2442,7 +3008,7 @@ describe('normalizeWorkflowDocument', () => {
         path: ['jobs', 'build', 'if'],
         details: expect.objectContaining({
           field: 'job.if',
-          unavailableRoots: ['execution.failed'],
+          unavailableRoots: ['execution'],
         }),
       }),
     ]);
@@ -2573,7 +3139,7 @@ describe('normalizeWorkflowDocument', () => {
     ]);
   });
 
-  it('rejects vars in job success with a server-predicate issue', () => {
+  it('accepts vars in job success', () => {
     const document: WorkflowDocument = {
       name: 'vars-context job success',
       jobs: {
@@ -2584,21 +3150,9 @@ describe('normalizeWorkflowDocument', () => {
       },
     };
 
-    const error = expectInvalid(document);
+    const model = normalizeWorkflowDocument(document);
 
-    expect(error.issues).toEqual([
-      expect.objectContaining({
-        code: 'vars-context-in-server-predicate',
-        message: expect.stringContaining('cannot reference vars'),
-        path: ['jobs', 'build', 'success'],
-        details: expect.objectContaining({
-          field: 'job.success',
-          source: 'vars.ENVIRONMENT == "prod"',
-          rejectedRoots: ['vars'],
-          site: 'job-resolution',
-        }),
-      }),
-    ]);
+    expect(model.jobs[0]?.success).toBe('vars.ENVIRONMENT == "prod"');
   });
 
   it('reports malformed job execution timeouts', () => {
@@ -3111,12 +3665,12 @@ describe('normalizeWorkflowDocument', () => {
     [
       'vars root',
       'vars.environment == "prod"',
-      'vars-context-in-server-predicate',
+      'context-unavailable-at-predicate-site',
       {
         field: 'trigger.filter',
         source: 'vars.environment == "prod"',
         contextRoots: ['vars'],
-        rejectedRoots: ['vars'],
+        unavailableRoots: ['vars'],
         site: 'ingest',
       },
     ],
@@ -3551,11 +4105,13 @@ describe('normalizeWorkflowDocument', () => {
             steps: [
               {
                 name: `deploy ${interpolation('event.action')}`,
+                working_directory: 'packages/api',
                 run: `deploy ${interpolation('run.id')}`,
                 env: {PR_TITLE: interpolation('event.pull_request.title'), DEBUG: false},
               },
               {
                 name: `review ${interpolation('inputs.topic')}`,
+                working_directory: `packages/${interpolation('inputs.topic')}`,
                 provider: 'openai',
                 prompt: `Review ${interpolation('event.pull_request.title')}`,
               },
@@ -3602,6 +4158,7 @@ describe('normalizeWorkflowDocument', () => {
       expect(model.jobs[0]?.steps[0]).toMatchObject({
         kind: 'run',
         command: {value: `deploy ${interpolation('run.id')}`},
+        workingDirectory: 'packages/api',
         templates: {
           command: [
             {kind: 'literal', value: 'deploy '},
@@ -3636,7 +4193,16 @@ describe('normalizeWorkflowDocument', () => {
       });
       expect(model.jobs[0]?.steps[1]).toMatchObject({
         kind: 'agent',
+        workingDirectory: `packages/${interpolation('inputs.topic')}`,
         templates: {
+          workingDirectory: [
+            {kind: 'literal', value: 'packages/'},
+            {
+              kind: 'deferred',
+              expression: {source: 'inputs.topic'},
+              roots: ['inputs'],
+            },
+          ],
           prompt: [
             {kind: 'literal', value: 'Review '},
             {
@@ -3678,7 +4244,7 @@ describe('normalizeWorkflowDocument', () => {
       expect(model).not.toHaveProperty('templates');
       expect(model.jobs[0]?.steps[0]).not.toHaveProperty('templates');
       expect(model.env).toEqual({VALUE: '$${{ event.ref }}'});
-      expect(model.jobs[0]?.name).toEqual([{kind: 'literal', value: 'Build app'}]);
+      expect(model.jobs[0]?.name).toBe('Build app');
       expect(model.jobs[0]?.steps[0]).toMatchObject({
         kind: 'run',
         command: {value: 'echo $${{ event.ref }}'},
@@ -3737,30 +4303,32 @@ describe('normalizeWorkflowDocument', () => {
 
     it.each([
       ['event payload', 'event.pull_request.title', ['event']],
-      ['job outputs', 'jobs.build.outputs.sha', ['jobs']],
-    ] as const)('rejects untrusted %s context in run commands with the env fix-it message', (_label, source, rejectedRoots) => {
+      ['job status', 'jobs.build.status', ['jobs']],
+    ] as const)('allows %s context in run commands', (_label, source, roots) => {
       const document: WorkflowDocument = {
         name: 'unsafe run',
         jobs: {
           build: {
+            steps: [{run: 'echo build'}],
+          },
+          deploy: {
+            needs: 'build',
             steps: [{run: `echo ${interpolation(source)}`}],
           },
         },
       };
 
-      const error = expectInvalid(document);
+      const model = normalizeWorkflowDocument(document);
 
-      expect(error.issues).toEqual([
-        expect.objectContaining({
-          code: 'untrusted-context-in-field',
-          path: ['jobs', 'build', 'steps', 0, 'run'],
-          message: expect.stringContaining('Bind untrusted values to env'),
-          details: expect.objectContaining({
-            field: 'run',
-            rejectedRoots,
-          }),
-        }),
-      ]);
+      expect(model.jobs[1]?.steps[0]).toMatchObject({
+        kind: 'run',
+        templates: {
+          command: [
+            {kind: 'literal', value: 'echo '},
+            {kind: 'deferred', roots},
+          ],
+        },
+      });
     });
 
     it('rejects secrets in agent fields', () => {
@@ -3832,8 +4400,7 @@ describe('normalizeWorkflowDocument', () => {
     it.each([
       'execution.events[0].data.body',
       'execution["events"][0].data.body',
-      'execution[x]',
-    ])('rejects untrusted execution sub-paths in run commands: %s', (source) => {
+    ])('allows execution event sub-paths in run commands: %s', (source) => {
       const document: WorkflowDocument = {
         name: 'unsafe execution run',
         jobs: {
@@ -3843,42 +4410,17 @@ describe('normalizeWorkflowDocument', () => {
         },
       };
 
-      const error = expectInvalid(document);
-
-      expect(error.issues).toEqual([
-        expect.objectContaining({
-          code: 'untrusted-context-in-field',
-          path: ['jobs', 'build', 'steps', 0, 'run'],
-          details: expect.objectContaining({
-            field: 'run',
-            rejectedRoots: ['execution'],
-          }),
-        }),
-      ]);
-    });
+      const model = normalizeWorkflowDocument(document);
 
-    it('rejects execution event access through CEL comprehension bindings in run commands', () => {
-      const document: WorkflowDocument = {
-        name: 'unsafe execution map run',
-        jobs: {
-          build: {
-            steps: [{run: `echo ${interpolation('executions.map(e, e.events[0].data.body)')}`}],
-          },
+      expect(model.jobs[0]?.steps[0]).toMatchObject({
+        kind: 'run',
+        templates: {
+          command: [
+            {kind: 'literal', value: 'echo '},
+            {kind: 'deferred', roots: ['execution']},
+          ],
         },
-      };
-
-      const error = expectInvalid(document);
-
-      expect(error.issues).toEqual([
-        expect.objectContaining({
-          code: 'untrusted-context-in-field',
-          path: ['jobs', 'build', 'steps', 0, 'run'],
-          details: expect.objectContaining({
-            field: 'run',
-            rejectedRoots: ['executions'],
-          }),
-        }),
-      ]);
+      });
     });
 
     it.each([
@@ -3994,7 +4536,7 @@ describe('normalizeWorkflowDocument', () => {
       });
     });
 
-    it('does not apply availability checks to job names', () => {
+    it('rejects dynamic job names in favor of execution_name', () => {
       const document: WorkflowDocument = {
         name: 'job display context',
         jobs: {
@@ -4010,16 +4552,19 @@ describe('normalizeWorkflowDocument', () => {
         },
       };
 
-      const model = normalizeWorkflowDocument(document);
-
-      expect(model.jobs[0]?.name?.[0]).toMatchObject({
-        kind: 'deferred',
-        roots: ['execution'],
-      });
-      expect(model.jobs[1]?.name?.[0]).toMatchObject({
-        kind: 'deferred',
-        roots: ['execution'],
-      });
+      const error = expectInvalid(document);
+      expect(error.issues).toEqual([
+        expect.objectContaining({
+          code: 'invalid-interpolation-template',
+          message: 'Job name must be literal. Move runtime interpolation to execution_name.',
+          path: ['jobs', 'build', 'name'],
+        }),
+        expect.objectContaining({
+          code: 'invalid-interpolation-template',
+          message: 'Job name must be literal. Move runtime interpolation to execution_name.',
+          path: ['jobs', 'review', 'name'],
+        }),
+      ]);
     });
 
     it('does not apply availability checks to workflow-level or job-level env', () => {
@@ -4149,7 +4694,7 @@ describe('normalizeWorkflowDocument', () => {
       });
     });
 
-    it('allows execution events in untrusted-capable fields', () => {
+    it('rejects execution events in static job names', () => {
       const document: WorkflowDocument = {
         name: 'execution events allowed',
         jobs: {
@@ -4161,25 +4706,13 @@ describe('normalizeWorkflowDocument', () => {
         },
       };
 
-      const model = normalizeWorkflowDocument(document);
-
-      expect(model.jobs[0]?.name?.[1]).toMatchObject({
-        kind: 'deferred',
-        expression: {check: 'typed'},
-        roots: ['execution'],
-      });
-      expect(model.jobs[0]?.steps[0]).toMatchObject({
-        kind: 'agent',
-        templates: {
-          prompt: [
-            {
-              kind: 'deferred',
-              expression: {check: 'typed'},
-              roots: ['execution'],
-            },
-          ],
-        },
-      });
+      const error = expectInvalid(document);
+      expect(error.issues).toEqual([
+        expect.objectContaining({
+          code: 'invalid-interpolation-template',
+          path: ['jobs', 'build', 'name'],
+        }),
+      ]);
     });
 
     it('allows untrusted context in env, prompt, and step names', () => {
@@ -4216,9 +4749,9 @@ describe('normalizeWorkflowDocument', () => {
     it.each([
       ['model', {model: interpolation('event.model'), prompt: 'Fix it.'}, 'event'],
       ['provider', {provider: interpolation('inputs.provider'), prompt: 'Fix it.'}, 'inputs'],
-    ] as const)('rejects untrusted agent %s interpolation', (_field, step, root) => {
+    ] as const)('allows external context in agent %s interpolation', (field, step, root) => {
       const document: WorkflowDocument = {
-        name: 'unsafe agent field',
+        name: 'external agent field',
         jobs: {
           fix: {
             steps: [step],
@@ -4226,14 +4759,77 @@ describe('normalizeWorkflowDocument', () => {
         },
       };
 
-      const error = expectInvalid(document);
+      const model = normalizeWorkflowDocument(document);
 
-      expect(error.issues).toEqual([
-        expect.objectContaining({
-          code: 'untrusted-context-in-field',
-          details: expect.objectContaining({rejectedRoots: [root]}),
-        }),
-      ]);
+      expect(model.jobs[0]?.steps[0]).toMatchObject({
+        kind: 'agent',
+        templates: {
+          [field]: [{kind: 'deferred', roots: [root]}],
+        },
+      });
+    });
+
+    it.each([
+      ['model', {model: interpolation('steps.collect.outputs.value'), prompt: 'Fix it.'}, 'steps'],
+      [
+        'provider',
+        {provider: interpolation('steps.collect.outputs.value'), prompt: 'Fix it.'},
+        'steps',
+      ],
+      [
+        'model',
+        {
+          model: interpolation('steps.filter(s, true).map(s, s.outputs.value)[0]'),
+          prompt: 'Fix it.',
+        },
+        'steps',
+      ],
+      [
+        'provider',
+        {
+          provider: interpolation('steps.filter(s, true).map(s, s.outputs.value)[0]'),
+          prompt: 'Fix it.',
+        },
+        'steps',
+      ],
+      [
+        'model',
+        {model: interpolation('execution.events[0].data.body'), prompt: 'Fix it.'},
+        'execution',
+      ],
+      [
+        'provider',
+        {provider: interpolation('execution.events[0].data.body'), prompt: 'Fix it.'},
+        'execution',
+      ],
+      [
+        'model',
+        {model: interpolation('execution["events"][0].data.body'), prompt: 'Fix it.'},
+        'execution',
+      ],
+      [
+        'provider',
+        {provider: interpolation('execution["events"][0].data.body'), prompt: 'Fix it.'},
+        'execution',
+      ],
+    ] as const)('allows path-specific external context in agent %s interpolation', (field, step, root) => {
+      const document: WorkflowDocument = {
+        name: 'path-specific external agent field',
+        jobs: {
+          fix: {
+            steps: [{key: 'collect', run: 'collect'}, step],
+          },
+        },
+      };
+
+      const model = normalizeWorkflowDocument(document);
+
+      expect(model.jobs[0]?.steps[1]).toMatchObject({
+        kind: 'agent',
+        templates: {
+          [field]: [{kind: 'deferred', roots: [root]}],
+        },
+      });
     });
 
     it.each([
@@ -4298,6 +4894,77 @@ describe('normalizeWorkflowDocument', () => {
       });
     });
 
+    it('does not add provider catalog issues for invalid provider interpolation', () => {
+      const document: WorkflowDocument = {
+        name: 'invalid provider interpolation',
+        jobs: {
+          fix: {
+            steps: [{harness: 'claude', provider: interpolation('foo.bar'), prompt: 'Fix it.'}],
+          },
+        },
+      };
+
+      const error = expectInvalid(document);
+
+      expect(error.issues).toEqual([
+        expect.objectContaining({
+          code: 'unknown-interpolation-context',
+          path: ['jobs', 'fix', 'steps', 0, 'provider'],
+        }),
+      ]);
+    });
+
+    it('skips static model catalog validation when model is interpolated', () => {
+      const document: WorkflowDocument = {
+        name: 'templated model',
+        jobs: {
+          fix: {
+            steps: [
+              {
+                provider: 'anthropic',
+                model: interpolation('run.name'),
+                prompt: 'Fix it.',
+              },
+            ],
+          },
+        },
+      };
+
+      const model = normalizeWorkflowDocument(document);
+
+      expect(model.jobs[0]?.steps[0]).toMatchObject({
+        kind: 'agent',
+        templates: {model: [{kind: 'deferred', roots: ['run']}]},
+      });
+    });
+
+    it('does not add model catalog issues for invalid model interpolation', () => {
+      const document: WorkflowDocument = {
+        name: 'invalid model interpolation',
+        jobs: {
+          fix: {
+            steps: [
+              {
+                harness: 'pi',
+                provider: 'anthropic',
+                model: interpolation('foo.bar'),
+                prompt: 'Fix it.',
+              },
+            ],
+          },
+        },
+      };
+
+      const error = expectInvalid(document);
+
+      expect(error.issues).toEqual([
+        expect.objectContaining({
+          code: 'unknown-interpolation-context',
+          path: ['jobs', 'fix', 'steps', 0, 'model'],
+        }),
+      ]);
+    });
+
     it('still validates literal providers through the catalog', () => {
       const document: WorkflowDocument = {
         name: 'literal provider',
@@ -4427,7 +5094,7 @@ describe('normalizeWorkflowDocument', () => {
       ]);
     });
 
-    it('uses syntax mode for mixed open contexts but still enforces minimum trust', () => {
+    it('uses syntax mode for mixed open contexts without a trust restriction', () => {
       const envDocument: WorkflowDocument = {
         name: 'mixed env',
         env: {MIXED: interpolation('run.nope + event.x')},
@@ -4447,22 +5114,25 @@ describe('normalizeWorkflowDocument', () => {
       };
 
       const model = normalizeWorkflowDocument(envDocument);
-      const error = expectInvalid(runDocument);
+      const runModel = normalizeWorkflowDocument(runDocument);
 
       expect(model.templates?.env?.MIXED?.[0]).toMatchObject({
         kind: 'deferred',
         expression: {check: 'syntax'},
         roots: expect.arrayContaining(['run', 'event']),
       });
-      expect(error.issues).toEqual([
-        expect.objectContaining({
-          code: 'untrusted-context-in-field',
-          path: ['jobs', 'build', 'steps', 0, 'run'],
-        }),
-      ]);
+      expect(runModel.jobs[0]?.steps[0]).toMatchObject({
+        kind: 'run',
+        templates: {
+          command: [
+            {kind: 'literal', value: 'echo '},
+            {kind: 'deferred', roots: expect.arrayContaining(['run', 'event'])},
+          ],
+        },
+      });
     });
 
-    it('reports one trust issue for a multi-segment run field with one untrusted segment', () => {
+    it('allows multi-segment run fields with external context', () => {
       const document: WorkflowDocument = {
         name: 'multi segment run',
         jobs: {
@@ -4472,14 +5142,18 @@ describe('normalizeWorkflowDocument', () => {
         },
       };
 
-      const error = expectInvalid(document);
+      const model = normalizeWorkflowDocument(document);
 
-      expect(error.issues).toEqual([
-        expect.objectContaining({
-          code: 'untrusted-context-in-field',
-          details: expect.objectContaining({rejectedRoots: ['event']}),
-        }),
-      ]);
+      expect(model.jobs[0]?.steps[0]).toMatchObject({
+        kind: 'run',
+        templates: {
+          command: [
+            {kind: 'deferred', roots: ['run']},
+            {kind: 'literal', value: '-'},
+            {kind: 'deferred', roots: ['event']},
+          ],
+        },
+      });
     });
 
     it('does not parse templates in non-string env values', () => {