@aion0/forge 0.10.12 → 0.10.17

package/lib/__tests__/foreach-before.test.ts

@@ -1,201 +0,0 @@
-/**
- * for_each.before: tests — covers:
- *   - parseWorkflow validates `before:` field shape + node existence
- *   - parseForEach passes through `before:` correctly
- *   - resolveForEachSource accepts node outputs (`{{nodes.X.outputs.Y}}`)
- *
- * Setup-phase orchestration (startPipeline scheduling, checkPipelineCompletion
- * transition) needs running tasks + file system + scheduler — not unit-testable
- * here. Verified end-to-end in fortinet-mr-review-batch v0.3.0.
- *
- * Run:  npx tsx lib/__tests__/foreach-before.test.ts
- */
-
-import { parseWorkflow, resolveForEachSource } from '../pipeline';
-
-let passed = 0, failed = 0;
-function check(name: string, fn: () => void) {
-  try { fn(); console.log(`  ✓ ${name}`); passed++; }
-  catch (e) { console.log(`  ✗ ${name}\n    ${(e as Error).message}`); failed++; }
-}
-function expectThrow(fn: () => void, msgIncludes: string) {
-  try { fn(); throw new Error(`expected throw containing "${msgIncludes}"`); }
-  catch (e) {
-    const m = (e as Error).message;
-    if (!m.includes(msgIncludes)) throw new Error(`got "${m}", expected to include "${msgIncludes}"`);
-  }
-}
-function eqArr(a: unknown[], b: unknown[], label = '') {
-  if (a.length !== b.length || a.some((v, i) => v !== b[i])) {
-    throw new Error(`${label}: expected ${JSON.stringify(b)}, got ${JSON.stringify(a)}`);
-  }
-}
-
-console.log('for_each.before parsing + node-output source resolution tests');
-
-// ── parseForEach / parseWorkflow: shape + validation ──
-
-check('parseWorkflow accepts valid before: [<node>]', () => {
-  const wf = parseWorkflow(`
-name: test
-for_each:
-  source: "{{nodes.list-ids.outputs.ids}}"
-  as: id
-  before: [list-ids]
-nodes:
-  list-ids:
-    project: x
-    prompt: "echo 1,2,3"
-  body:
-    project: x
-    prompt: "consume {{id}}"
-    depends_on: [list-ids]
-`);
-  if (!wf.for_each) throw new Error('for_each missing');
-  if (!wf.for_each.before) throw new Error('before missing');
-  eqArr(wf.for_each.before, ['list-ids']);
-});
-
-check('parseWorkflow accepts multi-node before: [a, b]', () => {
-  const wf = parseWorkflow(`
-name: test
-for_each:
-  source: "{{nodes.b.outputs.list}}"
-  as: x
-  before: [a, b]
-nodes:
-  a: { project: x, prompt: "1" }
-  b: { project: x, prompt: "2", depends_on: [a] }
-  body: { project: x, prompt: "{{x}}" }
-`);
-  eqArr(wf.for_each!.before!, ['a', 'b']);
-});
-
-check('parseWorkflow with NO before: → before undefined (back-compat)', () => {
-  const wf = parseWorkflow(`
-name: test
-for_each:
-  source: "{{input.ids}}"
-  as: id
-nodes:
-  body: { project: x, prompt: "{{id}}" }
-`);
-  if (wf.for_each!.before !== undefined) throw new Error(`expected undefined, got ${JSON.stringify(wf.for_each!.before)}`);
-});
-
-check('parseWorkflow throws on before referencing unknown node', () => {
-  expectThrow(() => parseWorkflow(`
-name: test
-for_each:
-  source: "{{nodes.missing.outputs.x}}"
-  as: id
-  before: [missing]
-nodes:
-  body: { project: x, prompt: "1" }
-`), "references unknown node id 'missing'");
-});
-
-check('parseWorkflow throws on before: not-an-array', () => {
-  expectThrow(() => parseWorkflow(`
-name: test
-for_each:
-  source: "{{nodes.list-ids.outputs.x}}"
-  as: id
-  before: "list-ids"
-nodes:
-  list-ids: { project: x, prompt: "1" }
-  body: { project: x, prompt: "{{id}}" }
-`), 'must be an array of node id strings');
-});
-
-check('parseWorkflow throws on before: [empty-string]', () => {
-  expectThrow(() => parseWorkflow(`
-name: test
-for_each:
-  source: "{{nodes.x.outputs.x}}"
-  as: id
-  before: [""]
-nodes:
-  x: { project: x, prompt: "1" }
-  body: { project: x, prompt: "{{id}}" }
-`), 'must be an array of node id strings');
-});
-
-check('parseWorkflow throws on before: [non-string]', () => {
-  expectThrow(() => parseWorkflow(`
-name: test
-for_each:
-  source: "{{nodes.x.outputs.x}}"
-  as: id
-  before: [123]
-nodes:
-  x: { project: x, prompt: "1" }
-  body: { project: x, prompt: "{{id}}" }
-`), 'must be an array of node id strings');
-});
-
-// ── resolveForEachSource: ctx now includes nodes ──
-
-check('resolveForEachSource reads {{nodes.X.outputs.Y}} from pipeline.nodes', () => {
-  const nodes = {
-    'list-ids': { status: 'done' as const, outputs: { ids: '7,8,9' }, iterations: 0 },
-  };
-  const items = resolveForEachSource(
-    { source: '{{nodes.list-ids.outputs.ids}}' },
-    {},
-    {},
-    nodes,
-  );
-  eqArr(items, ['7', '8', '9']);
-});
-
-check('resolveForEachSource trims whitespace from node-output split items', () => {
-  const nodes = {
-    'list-ids': { status: 'done' as const, outputs: { ids: ' 1, 2 ,3 ' }, iterations: 0 },
-  };
-  const items = resolveForEachSource(
-    { source: '{{nodes.list-ids.outputs.ids}}' },
-    {},
-    {},
-    nodes,
-  );
-  eqArr(items, ['1', '2', '3']);
-});
-
-check('resolveForEachSource empty node output → empty array', () => {
-  const nodes = {
-    'list-ids': { status: 'done' as const, outputs: { ids: '' }, iterations: 0 },
-  };
-  const items = resolveForEachSource(
-    { source: '{{nodes.list-ids.outputs.ids}}' },
-    {},
-    {},
-    nodes,
-  );
-  eqArr(items, []);
-});
-
-check('resolveForEachSource with custom split + node output', () => {
-  const nodes = {
-    'list-ids': { status: 'done' as const, outputs: { ids: 'a|b|c' }, iterations: 0 },
-  };
-  const items = resolveForEachSource(
-    { source: '{{nodes.list-ids.outputs.ids}}', split: '|' },
-    {},
-    {},
-    nodes,
-  );
-  eqArr(items, ['a', 'b', 'c']);
-});
-
-check('resolveForEachSource without nodes param (back-compat) still works', () => {
-  const items = resolveForEachSource(
-    { source: '{{input.ids}}' },
-    { ids: '1,2' },
-    {},
-  );
-  eqArr(items, ['1', '2']);
-});
-
-console.log(`\n${passed} passed, ${failed} failed`);
-process.exit(failed === 0 ? 0 : 1);

package/lib/__tests__/foreach-parse.test.ts

@@ -1,114 +0,0 @@
-/**
- * Step-2 verification: parseWorkflow handles `for_each:` correctly.
- *
- * No test framework — just a tsx script that throws on first failure.
- * Run:  npx tsx lib/__tests__/foreach-parse.test.ts
- */
-
-import { parseWorkflow } from '../pipeline';
-
-let passed = 0;
-let failed = 0;
-
-function check(name: string, fn: () => void) {
-  try { fn(); console.log(`  ✓ ${name}`); passed++; }
-  catch (e) { console.log(`  ✗ ${name}\n    ${(e as Error).message}`); failed++; }
-}
-
-function expectThrow(yaml: string, expectedSubstring: string) {
-  try {
-    parseWorkflow(yaml);
-    throw new Error(`expected throw containing "${expectedSubstring}", got none`);
-  } catch (e) {
-    const msg = (e as Error).message;
-    if (!msg.includes(expectedSubstring)) {
-      throw new Error(`expected throw containing "${expectedSubstring}", got: ${msg}`);
-    }
-  }
-}
-
-console.log('parseWorkflow + for_each: parser tests');
-
-check('no for_each → workflow.for_each is undefined', () => {
-  const w = parseWorkflow('name: foo\nnodes:\n  a: { project: x, prompt: "echo hi" }\n');
-  if (w.for_each !== undefined) throw new Error(`expected undefined, got ${JSON.stringify(w.for_each)}`);
-});
-
-check('valid for_each with string source', () => {
-  const w = parseWorkflow(`
-name: foo
-for_each:
-  source: "{{input.ids}}"
-  as: bug_id
-nodes:
-  a: { project: x, prompt: "echo {{bug_id}}" }
-`);
-  if (!w.for_each) throw new Error('for_each missing');
-  if (w.for_each.source !== '{{input.ids}}') throw new Error('source wrong');
-  if (w.for_each.as !== 'bug_id') throw new Error('as wrong');
-  if (w.for_each.on_failure !== 'continue') throw new Error(`on_failure default should be continue, got ${w.for_each.on_failure}`);
-});
-
-check('default as = "item"', () => {
-  const w = parseWorkflow('name: foo\nfor_each:\n  source: "{{input.x}}"\nnodes:\n  a: { project: x, prompt: "" }\n');
-  if (w.for_each!.as !== 'item') throw new Error('default as should be item');
-});
-
-check('on_failure: stop accepted', () => {
-  const w = parseWorkflow('name: foo\nfor_each:\n  source: x\n  on_failure: stop\nnodes:\n  a: { project: x, prompt: "" }\n');
-  if (w.for_each!.on_failure !== 'stop') throw new Error('on_failure not preserved');
-});
-
-check('array source literal', () => {
-  const w = parseWorkflow('name: foo\nfor_each:\n  source: [1, 2, 3]\nnodes:\n  a: { project: x, prompt: "" }\n');
-  if (!Array.isArray(w.for_each!.source)) throw new Error('array literal not preserved');
-  if ((w.for_each!.source as any[]).length !== 3) throw new Error('array length wrong');
-});
-
-check('split: ";" accepted', () => {
-  const w = parseWorkflow('name: foo\nfor_each:\n  source: x\n  split: ";"\nnodes:\n  a: { project: x, prompt: "" }\n');
-  if (w.for_each!.split !== ';') throw new Error('split not preserved');
-});
-
-console.log('\nError-path tests:');
-
-check('throws on missing source', () => {
-  expectThrow('name: foo\nfor_each:\n  as: bug\nnodes:\n  a: { project: x, prompt: "" }\n', 'source is required');
-});
-
-check('throws on invalid as identifier', () => {
-  expectThrow('name: foo\nfor_each:\n  source: x\n  as: "bad-name"\nnodes:\n  a: { project: x, prompt: "" }\n', 'must be a valid identifier');
-});
-
-check('throws on reserved as: input', () => {
-  expectThrow('name: foo\nfor_each:\n  source: x\n  as: input\nnodes:\n  a: { project: x, prompt: "" }\n', 'reserved template namespace');
-});
-
-check('throws on reserved as: run', () => {
-  expectThrow('name: foo\nfor_each:\n  source: x\n  as: run\nnodes:\n  a: { project: x, prompt: "" }\n', 'reserved template namespace');
-});
-
-check('throws on bad on_failure value', () => {
-  expectThrow('name: foo\nfor_each:\n  source: x\n  on_failure: maybe\nnodes:\n  a: { project: x, prompt: "" }\n', "must be 'continue' or 'stop'");
-});
-
-check('throws on for_each on conversation type', () => {
-  expectThrow(`
-name: foo
-type: conversation
-for_each:
-  source: x
-agents:
-  - id: a
-    agent: claude
-initial_prompt: hi
-nodes: {}
-`, "only supported on type='dag'");
-});
-
-check('throws on for_each scalar (not object)', () => {
-  expectThrow('name: foo\nfor_each: "{{input.ids}}"\nnodes:\n  a: { project: x, prompt: "" }\n', 'must be an object');
-});
-
-console.log(`\n${passed} passed, ${failed} failed`);
-process.exit(failed === 0 ? 0 : 1);

package/lib/__tests__/foreach-snapshot.test.ts

@@ -1,112 +0,0 @@
-/**
- * Step-5 verification: snapshotIteration captures node states + correctly
- * advances the iterations[] history. (Full checkPipelineCompletion has
- * filesystem + scheduling side effects — exercised end-to-end in Step 7.)
- *
- * Run:  npx tsx lib/__tests__/foreach-snapshot.test.ts
- */
-
-import { snapshotIteration } from '../pipeline';
-
-let passed = 0, failed = 0;
-function check(name: string, fn: () => void) {
-  try { fn(); console.log(`  ✓ ${name}`); passed++; }
-  catch (e) { console.log(`  ✗ ${name}\n    ${(e as Error).message}`); failed++; }
-}
-
-function makePipeline(items: unknown[], currentIndex = 0): any {
-  return {
-    id: 'test123',
-    workflowName: 'test',
-    status: 'running',
-    input: {},
-    vars: {},
-    nodes: {
-      a: { status: 'done', outputs: { x: '1' } },
-      b: { status: 'done', outputs: { y: '2' }, error: undefined },
-    },
-    nodeOrder: ['a', 'b'],
-    createdAt: '2026-01-01T00:00:00.000Z',
-    forEach: {
-      items,
-      currentIndex,
-      total: items.length,
-      asName: 'item',
-      onFailure: 'continue',
-      iterations: [],
-    },
-  };
-}
-
-console.log('snapshotIteration tests');
-
-check('snapshot captures all-done nodes with status="done"', () => {
-  const p = makePipeline([1, 2, 3]);
-  snapshotIteration(p, false);
-  if (p.forEach.iterations.length !== 1) throw new Error('iterations length wrong');
-  const iter = p.forEach.iterations[0];
-  if (iter.status !== 'done') throw new Error(`status wrong: ${iter.status}`);
-  if (iter.index !== 0) throw new Error('index wrong');
-  if (iter.nodes.a.status !== 'done') throw new Error('node a status wrong');
-  if (iter.nodes.a.outputs.x !== '1') throw new Error('node a output not preserved');
-});
-
-check('snapshot captures failed iter with status="failed"', () => {
-  const p = makePipeline([1, 2]);
-  p.nodes.b.status = 'failed';
-  p.nodes.b.error = 'boom';
-  snapshotIteration(p, true);
-  const iter = p.forEach.iterations[0];
-  if (iter.status !== 'failed') throw new Error(`status wrong: ${iter.status}`);
-  if (iter.nodes.b.error !== 'boom') throw new Error('error not preserved');
-});
-
-check('startedAt = createdAt for first iter', () => {
-  const p = makePipeline([1, 2]);
-  snapshotIteration(p, false);
-  if (p.forEach.iterations[0].startedAt !== p.createdAt) throw new Error('first startedAt should = createdAt');
-});
-
-check('startedAt = previous completedAt for subsequent iters', () => {
-  const p = makePipeline([1, 2]);
-  snapshotIteration(p, false);
-  const firstCompleted = p.forEach.iterations[0].completedAt;
-  p.forEach.currentIndex = 1;
-  snapshotIteration(p, false);
-  if (p.forEach.iterations[1].startedAt !== firstCompleted) {
-    throw new Error('second iter startedAt should chain from prev completedAt');
-  }
-});
-
-check('outputs are deep-copied (mutation safety)', () => {
-  const p = makePipeline([1]);
-  snapshotIteration(p, false);
-  const iter = p.forEach.iterations[0];
-  // Mutate live node — snapshot should NOT change
-  p.nodes.a.outputs.x = 'MUTATED';
-  if (iter.nodes.a.outputs.x !== '1') throw new Error('snapshot was mutated; need defensive copy');
-});
-
-check('multiple iterations accumulate', () => {
-  const p = makePipeline([1, 2, 3]);
-  snapshotIteration(p, false);
-  p.forEach.currentIndex = 1;
-  snapshotIteration(p, false);
-  p.forEach.currentIndex = 2;
-  snapshotIteration(p, true);
-  if (p.forEach.iterations.length !== 3) throw new Error('expected 3 iters');
-  if (p.forEach.iterations[2].status !== 'failed') throw new Error('iter 3 should be failed');
-  if (p.forEach.iterations[0].index !== 0) throw new Error('iter 0 index wrong');
-  if (p.forEach.iterations[1].index !== 1) throw new Error('iter 1 index wrong');
-  if (p.forEach.iterations[2].index !== 2) throw new Error('iter 2 index wrong');
-});
-
-check('no-op when pipeline.forEach undefined', () => {
-  const p: any = { id: 'x', nodes: {}, createdAt: '2026-01-01' };
-  snapshotIteration(p, false);
-  // Should not throw, should not add anything
-  if (p.forEach !== undefined) throw new Error('should leave forEach undefined');
-});
-
-console.log(`\n${passed} passed, ${failed} failed`);
-process.exit(failed === 0 ? 0 : 1);

package/lib/__tests__/foreach-source.test.ts

@@ -1,105 +0,0 @@
-/**
- * Step-4 verification: resolveForEachSource resolves + splits items.
- * Run:  npx tsx lib/__tests__/foreach-source.test.ts
- */
-
-import { resolveForEachSource } from '../pipeline';
-
-let passed = 0, failed = 0;
-function check(name: string, fn: () => void) {
-  try { fn(); console.log(`  ✓ ${name}`); passed++; }
-  catch (e) { console.log(`  ✗ ${name}\n    ${(e as Error).message}`); failed++; }
-}
-function eqArr(a: unknown[], b: unknown[], label = '') {
-  if (a.length !== b.length || a.some((v, i) => v !== b[i])) {
-    throw new Error(`${label}: expected ${JSON.stringify(b)}, got ${JSON.stringify(a)}`);
-  }
-}
-
-console.log('resolveForEachSource tests');
-
-check('string source via {{input.x}} template, default split=","', () => {
-  const items = resolveForEachSource(
-    { source: '{{input.ids}}' },
-    { ids: '111,222,333' },
-    {},
-  );
-  eqArr(items, ['111', '222', '333']);
-});
-
-check('string source with whitespace around commas — trimmed', () => {
-  const items = resolveForEachSource(
-    { source: '{{input.ids}}' },
-    { ids: ' 111 ,222 , 333  ' },
-    {},
-  );
-  eqArr(items, ['111', '222', '333']);
-});
-
-check('string source with empty entries dropped', () => {
-  const items = resolveForEachSource(
-    { source: '{{input.ids}}' },
-    { ids: '111,,222, ,333,' },
-    {},
-  );
-  eqArr(items, ['111', '222', '333']);
-});
-
-check('empty input.ids → empty array', () => {
-  const items = resolveForEachSource({ source: '{{input.ids}}' }, { ids: '' }, {});
-  eqArr(items, []);
-});
-
-check('input missing → empty string template → empty array', () => {
-  const items = resolveForEachSource({ source: '{{input.missing}}' }, {}, {});
-  eqArr(items, []);
-});
-
-check('custom split: ";"', () => {
-  const items = resolveForEachSource(
-    { source: '{{input.ids}}', split: ';' },
-    { ids: '111;222;333' },
-    {},
-  );
-  eqArr(items, ['111', '222', '333']);
-});
-
-check('array literal source — used as-is', () => {
-  const items = resolveForEachSource(
-    { source: ['a', 'b', 'c'] },
-    {},
-    {},
-  );
-  eqArr(items, ['a', 'b', 'c']);
-});
-
-check('array literal with objects — preserved', () => {
-  const items = resolveForEachSource(
-    { source: [{ iid: 1 }, { iid: 2 }] },
-    {},
-    {},
-  );
-  if (items.length !== 2) throw new Error('length wrong');
-  if ((items[0] as any).iid !== 1) throw new Error('first item wrong');
-});
-
-check('vars source resolves', () => {
-  const items = resolveForEachSource(
-    { source: '{{vars.list}}' },
-    {},
-    { list: 'a,b,c' },
-  );
-  eqArr(items, ['a', 'b', 'c']);
-});
-
-check('literal string with no template, just split', () => {
-  const items = resolveForEachSource(
-    { source: 'foo,bar' },
-    {},
-    {},
-  );
-  eqArr(items, ['foo', 'bar']);
-});
-
-console.log(`\n${passed} passed, ${failed} failed`);
-process.exit(failed === 0 ? 0 : 1);

package/lib/__tests__/foreach-template.test.ts

@@ -1,112 +0,0 @@
-/**
- * Step-3 verification: resolveTemplate handles for_each context.
- * Run:  npx tsx lib/__tests__/foreach-template.test.ts
- */
-
-import { resolveTemplate } from '../pipeline';
-
-let passed = 0;
-let failed = 0;
-function check(name: string, fn: () => void) {
-  try { fn(); console.log(`  ✓ ${name}`); passed++; }
-  catch (e) { console.log(`  ✗ ${name}\n    ${(e as Error).message}`); failed++; }
-}
-function eq(actual: string, expected: string, label = '') {
-  if (actual !== expected) {
-    throw new Error(`${label}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
-  }
-}
-
-const baseCtx = { input: {}, vars: {}, nodes: {} };
-
-console.log('resolveTemplate + for_each tests');
-
-check('no forEach in ctx — {{item}} is literal passthrough', () => {
-  eq(resolveTemplate('hello {{item}}', baseCtx), 'hello {{item}}');
-});
-
-check('scalar item: {{<as>}} substitutes', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'bug_id', item: 1213844, index: 0, total: 3 } };
-  eq(resolveTemplate('Fix bug {{bug_id}} now', ctx), 'Fix bug 1213844 now');
-});
-
-check('string item: {{<as>}} preserves string', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'name', item: 'alice', index: 0, total: 1 } };
-  eq(resolveTemplate('hi {{name}}', ctx), 'hi alice');
-});
-
-check('object item: {{<as>.field}} dotted access', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'mr', item: { iid: 42, title: 'fix x' }, index: 0, total: 1 } };
-  eq(resolveTemplate('MR !{{mr.iid}}: {{mr.title}}', ctx), 'MR !42: fix x');
-});
-
-check('object item: missing field → empty string', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'mr', item: { iid: 42 }, index: 0, total: 1 } };
-  eq(resolveTemplate('author=@{{mr.author}}', ctx), 'author=@');
-});
-
-check('object item: {{<as>}} alone → JSON', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'mr', item: { iid: 42, t: 'x' }, index: 0, total: 1 } };
-  eq(resolveTemplate('raw={{mr}}', ctx), 'raw={"iid":42,"t":"x"}');
-});
-
-check('{{loop.index}} + {{loop.total}}', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'item', item: 'x', index: 2, total: 5 } };
-  eq(resolveTemplate('Step {{loop.index}} of {{loop.total}}', ctx), 'Step 2 of 5');
-});
-
-check('shellMode escapes scalar item', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'name', item: "o'brien", index: 0, total: 1 } };
-  // shellEscapeAnsiC: ' → \'
-  const out = resolveTemplate("echo '{{name}}'", ctx, true);
-  if (!out.includes("o\\'brien")) throw new Error(`expected escaped apostrophe, got: ${out}`);
-});
-
-check('{{raw:<as>}} bypasses shell escape', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'name', item: "o'brien", index: 0, total: 1 } };
-  // raw: keeps verbatim
-  eq(resolveTemplate('{{raw:name}}', ctx, true), "o'brien");
-});
-
-check('input.x still works alongside forEach', () => {
-  const ctx = { input: { proj: 'FortiNAC' }, vars: {}, nodes: {}, forEach: { asName: 'bug_id', item: 1, index: 0, total: 1 } };
-  eq(resolveTemplate('{{input.proj}}/mantis-{{bug_id}}', ctx), 'FortiNAC/mantis-1');
-});
-
-check('nodes.X.outputs.Y still works alongside forEach', () => {
-  const ctx: any = {
-    input: {},
-    vars: {},
-    nodes: { ingest: { status: 'done', outputs: { ctx: 'hello' }, iterations: 1 } },
-    forEach: { asName: 'item', item: 'x', index: 0, total: 1 },
-  };
-  eq(resolveTemplate('{{nodes.ingest.outputs.ctx}}/{{item}}', ctx), 'hello/x');
-});
-
-check('run.tmp_dir still works alongside forEach', () => {
-  const ctx = {
-    ...baseCtx,
-    tmpDir: '/path/.forge/worktrees/pipeline-abc',
-    forEach: { asName: 'bug_id', item: 42, index: 0, total: 1 },
-  };
-  eq(resolveTemplate('{{run.tmp_dir}}/mantis-{{bug_id}}', ctx),
-     '/path/.forge/worktrees/pipeline-abc/mantis-42');
-});
-
-check('forEach.item = null → empty string', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'x', item: null, index: 0, total: 1 } };
-  eq(resolveTemplate('[{{x}}]', ctx), '[]');
-});
-
-check('forEach.item = false → "false"', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'x', item: false, index: 0, total: 1 } };
-  eq(resolveTemplate('[{{x}}]', ctx), '[false]');
-});
-
-check('loop.index works even when item is undefined-but-asName-set (defensive)', () => {
-  const ctx = { ...baseCtx, forEach: { asName: 'item', item: undefined, index: 7, total: 9 } };
-  eq(resolveTemplate('{{loop.index}}/{{loop.total}}', ctx), '7/9');
-});
-
-console.log(`\n${passed} passed, ${failed} failed`);
-process.exit(failed === 0 ? 0 : 1);