'use strict';

/**
 * loop-render-hooks.test.cjs — behavioral tests for loop-resolver.cjs.
 *
 * ADR-857 phase 3c.
 * Uses node:test + node:assert/strict.
 * Pure-function tests (resolveLoopHooks, renderLoopHooks) pass registry+config
 * directly — no I/O. End-to-end tests use cmdLoopRenderHooks + a temp project.
 */

const { describe, test, before, after } = require('node:test');
const assert = require('node:assert/strict');
const fs = require('node:fs');
const os = require('node:os');
const path = require('node:path');

const { cleanup } = require('./helpers.cjs');

const {
  resolveLoopHooks,
  renderLoopHooks,
  _getNestedConfigValue,
  _resolveActivationValue,
  _readRawConfigKey,
  CANONICAL_POINTS_FALLBACK,
  CANONICAL_POINTS,
} = require('../gsd-core/bin/lib/loop-resolver.cjs');

// The real registry for integration tests
const realRegistry = require('../gsd-core/bin/lib/capability-registry.cjs');

// ─── Synthetic registry fixtures ─────────────────────────────────────────────

/**
 * Build a minimal synthetic registry with a single step hook at a given point.
 * Optionally include a configSchema for testing default-based activation.
 */
function makeRegistry({ point = 'plan:pre', steps = [], contributions = [], gates = {}, configSchema = {} } = {}) {
  const byLoopPoint = {};
  for (const p of CANONICAL_POINTS_FALLBACK) {
    byLoopPoint[p] = { steps: [], contributions: [], gates: [] };
  }
  if (steps.length) byLoopPoint[point].steps = steps;
  if (contributions.length) byLoopPoint[point].contributions = contributions;
  if (gates[point]) byLoopPoint[point].gates = gates[point];
  return { byLoopPoint, configSchema };
}

// ─── Temp project helpers ─────────────────────────────────────────────────────

let tmpProjectDir;
// A project with NO .planning/config.json — relies on schema defaults
let tmpEmptyProjectDir;
// A project where ui_phase is explicitly false in root config
let tmpFalseConfigProjectDir;

before(() => {
  tmpProjectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'loop-resolver-test-'));
  const planningDir = path.join(tmpProjectDir, '.planning');
  fs.mkdirSync(planningDir, { recursive: true });
  // Write minimal config.json with all UI flags enabled
  fs.writeFileSync(
    path.join(planningDir, 'config.json'),
    JSON.stringify({ workflow: { ui_phase: true, ui_review: true, ui_safety_gate: true } }),
    'utf8',
  );

  // Empty project — no config.json: schema defaults drive activation
  tmpEmptyProjectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'loop-resolver-empty-'));
  fs.mkdirSync(path.join(tmpEmptyProjectDir, '.planning'), { recursive: true });

  // False config project — ui_phase explicitly false in root config
  tmpFalseConfigProjectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'loop-resolver-false-'));
  const falseConfigPlanningDir = path.join(tmpFalseConfigProjectDir, '.planning');
  fs.mkdirSync(falseConfigPlanningDir, { recursive: true });
  fs.writeFileSync(
    path.join(falseConfigPlanningDir, 'config.json'),
    JSON.stringify({ workflow: { ui_phase: false, ui_review: false, ui_safety_gate: false } }),
    'utf8',
  );
});

after(() => {
  if (tmpProjectDir) cleanup(tmpProjectDir);
  if (tmpEmptyProjectDir) cleanup(tmpEmptyProjectDir);
  if (tmpFalseConfigProjectDir) cleanup(tmpFalseConfigProjectDir);
});

// ─── 1. Canonical-point validation ───────────────────────────────────────────

describe('canonical point validation', () => {
  test('all 12 canonical points are accepted by resolveLoopHooks with empty registry', () => {
    const emptyRegistry = makeRegistry();
    const config = {};
    for (const p of CANONICAL_POINTS_FALLBACK) {
      const result = resolveLoopHooks({ point: p, registry: emptyRegistry, config });
      assert.strictEqual(result.point, p);
      assert.deepEqual(result.activeHooks, []);
    }
  });

  test('12 canonical points total', () => {
    assert.strictEqual(CANONICAL_POINTS_FALLBACK.length, 12);
  });

  test('invalid point throws with a clear message', () => {
    const emptyRegistry = makeRegistry();
    assert.throws(
      () => resolveLoopHooks({ point: 'plan:mid', registry: emptyRegistry, config: {} }),
      (err) => {
        assert.ok(err instanceof Error);
        assert.match(err.message, /Invalid loop point/);
        assert.match(err.message, /plan:mid/);
        return true;
      },
    );
  });

  test('empty string point throws', () => {
    const emptyRegistry = makeRegistry();
    assert.throws(
      () => resolveLoopHooks({ point: '', registry: emptyRegistry, config: {} }),
      /Invalid loop point/,
    );
  });

  test('close typo throws', () => {
    const emptyRegistry = makeRegistry();
    assert.throws(
      () => resolveLoopHooks({ point: 'plan:pre ', registry: emptyRegistry, config: {} }),
      /Invalid loop point/,
    );
  });

  // FIX 2: non-canonical point rejected even if the registry has it as a byLoopPoint key
  test('non-canonical point in registry byLoopPoint is still rejected', () => {
    // Craft a registry that has a synthetic non-canonical key in byLoopPoint
    const registry = {
      byLoopPoint: {
        // All canonical points (needed so the registry is well-formed)
        ...Object.fromEntries(CANONICAL_POINTS_FALLBACK.map(p => [p, { steps: [], contributions: [], gates: [] }])),
        // A non-canonical key that a malformed registry might inject
        'inject:arbitrary': { steps: [{ capId: 'evil', ref: { skill: 'bad' } }], contributions: [], gates: [] },
      },
    };
    assert.throws(
      () => resolveLoopHooks({ point: 'inject:arbitrary', registry, config: {} }),
      /Invalid loop point/,
    );
  });

  // FIX 2: all 12 canonical points are listed in the error message
  test('invalid point error lists the canonical 12', () => {
    const emptyRegistry = makeRegistry();
    assert.throws(
      () => resolveLoopHooks({ point: 'not:real', registry: emptyRegistry, config: {} }),
      (err) => {
        assert.ok(err instanceof Error);
        for (const p of CANONICAL_POINTS_FALLBACK) {
          assert.ok(err.message.includes(p), `Expected "${p}" in error message: ${err.message}`);
        }
        return true;
      },
    );
  });

  // CANONICAL_POINTS is derived from LOOP_HOST_CONTRACT, not from registry keys
  test('CANONICAL_POINTS and CANONICAL_POINTS_FALLBACK are the same 12 points', () => {
    assert.deepEqual(CANONICAL_POINTS, CANONICAL_POINTS_FALLBACK);
    assert.strictEqual(CANONICAL_POINTS.length, 12);
  });
});

// ─── 2. Activation tests ─────────────────────────────────────────────────────

describe('activation filter', () => {
  test('hook with no "when" is always active', () => {
    const registry = makeRegistry({
      steps: [{ capId: 'test-cap', point: 'plan:pre', ref: { skill: 'my-skill' } }],
    });
    const result = resolveLoopHooks({ point: 'plan:pre', registry, config: {} });
    assert.strictEqual(result.activeHooks.length, 1);
    assert.strictEqual(result.activeHooks[0].capId, 'test-cap');
  });

  test('hook with when="mytool.on", config{mytool:{on:true}} → active', () => {
    const registry = makeRegistry({
      steps: [{ capId: 'test-cap', point: 'plan:pre', ref: { skill: 'my-skill' }, when: 'mytool.on' }],
    });
    const config = { mytool: { on: true } };
    const result = resolveLoopHooks({ point: 'plan:pre', registry, config });
    assert.strictEqual(result.activeHooks.length, 1);
    assert.strictEqual(result.activeHooks[0].kind, 'step');
  });

  test('hook with when="mytool.on", config{mytool:{on:false}} → filtered', () => {
    const registry = makeRegistry({
      steps: [{ capId: 'test-cap', point: 'plan:pre', ref: { skill: 'my-skill' }, when: 'mytool.on' }],
    });
    const config = { mytool: { on: false } };
    const result = resolveLoopHooks({ point: 'plan:pre', registry, config });
    assert.strictEqual(result.activeHooks.length, 0);
  });

  test('hook with when="mytool.on", config{} (absent key) → filtered', () => {
    const registry = makeRegistry({
      steps: [{ capId: 'test-cap', point: 'plan:pre', ref: { skill: 'my-skill' }, when: 'mytool.on' }],
    });
    const result = resolveLoopHooks({ point: 'plan:pre', registry, config: {} });
    assert.strictEqual(result.activeHooks.length, 0);
  });

  test('hook with when="mytool.on", config{mytool:{}} → filtered (key absent)', () => {
    const registry = makeRegistry({
      steps: [{ capId: 'test-cap', point: 'plan:pre', ref: { skill: 'my-skill' }, when: 'mytool.on' }],
    });
    const config = { mytool: {} };
    const result = resolveLoopHooks({ point: 'plan:pre', registry, config });
    assert.strictEqual(result.activeHooks.length, 0);
  });

  // FIX 3: non-string `when` → INACTIVE (not always-active)
  test('hook with when=true (boolean) → inactive (FIX 3: malformed non-string when)', () => {
    const registry = makeRegistry({
      steps: [{ capId: 'test-cap', point: 'plan:pre', ref: { skill: 'my-skill' }, when: true }],
    });
    const result = resolveLoopHooks({ point: 'plan:pre', registry, config: {} });
    assert.strictEqual(result.activeHooks.length, 0, 'non-string when=true must be treated as inactive');
  });

  test('hook with when=42 (number) → inactive (FIX 3)', () => {
    const registry = makeRegistry({
      steps: [{ capId: 'test-cap', point: 'plan:pre', ref: { skill: 'my-skill' }, when: 42 }],
    });
    const result = resolveLoopHooks({ point: 'plan:pre', registry, config: {} });
    assert.strictEqual(result.activeHooks.length, 0, 'non-string when=42 must be inactive');
  });

  test('hook with when={} (object) → inactive (FIX 3)', () => {
    const registry = makeRegistry({
      steps: [{ capId: 'test-cap', point: 'plan:pre', ref: { skill: 'my-skill' }, when: {} }],
    });
    const result = resolveLoopHooks({ point: 'plan:pre', registry, config: {} });
    assert.strictEqual(result.activeHooks.length, 0, 'non-string when={} must be inactive');
  });

  // FIX 4: configSchema default=true → active with absent config (no cwd → level 4 applies)
  test('configSchema default=true + absent config → active', () => {
    const registry = makeRegistry({
      steps: [{ capId: 'test-cap', point: 'plan:pre', ref: { skill: 'my-skill' }, when: 'mytool.on' }],
      configSchema: {
        'mytool.on': { type: 'boolean', default: true, description: 'Enable mytool.' },
      },
    });
    const result = resolveLoopHooks({ point: 'plan:pre', registry, config: {} });
    assert.strictEqual(result.activeHooks.length, 1, 'schema default=true should activate the hook');
    assert.strictEqual(result.activeHooks[0].capId, 'test-cap');
  });

  // FIX 4: configSchema default=false → inactive with absent config
  test('configSchema default=false + absent config → inactive', () => {
    const registry = makeRegistry({
      steps: [{ capId: 'test-cap', point: 'plan:pre', ref: { skill: 'my-skill' }, when: 'mytool.on' }],
      configSchema: {
        'mytool.on': { type: 'boolean', default: false, description: 'Disabled by default.' },
      },
    });
    const result = resolveLoopHooks({ point: 'plan:pre', registry, config: {} });
    assert.strictEqual(result.activeHooks.length, 0, 'schema default=false should keep hook inactive');
  });

  // FIX 4: configSchema default=true but explicit config override=false → inactive (config wins)
  test('configSchema default=true but config override false → inactive (config wins)', () => {
    const registry = makeRegistry({
      steps: [{ capId: 'test-cap', point: 'plan:pre', ref: { skill: 'my-skill' }, when: 'mytool.on' }],
      configSchema: {
        'mytool.on': { type: 'boolean', default: true, description: 'Enabled by default.' },
      },
    });
    const config = { mytool: { on: false } };
    const result = resolveLoopHooks({ point: 'plan:pre', registry, config });
    assert.strictEqual(result.activeHooks.length, 0, 'explicit config=false overrides schema default=true');
  });
});

// ─── 3. UI pilot integration tests ───────────────────────────────────────────

describe('UI pilot integration', () => {
  test('plan:pre with workflow.ui_phase=true → ui-phase step active', () => {
    const config = { workflow: { ui_phase: true, ui_review: true, ui_safety_gate: true } };
    const result = resolveLoopHooks({ point: 'plan:pre', registry: realRegistry, config });
    const uiStep = result.activeHooks.find(h => h.capId === 'ui' && h.kind === 'step');
    assert.ok(uiStep, 'Expected ui step at plan:pre');
    assert.deepEqual(uiStep.ref, { skill: 'ui-phase' });
    assert.ok(Array.isArray(uiStep.produces));
    assert.ok(uiStep.produces.includes('UI-SPEC.md'));
  });

  test('plan:pre with workflow.ui_phase=false → ui-phase step filtered', () => {
    const config = { workflow: { ui_phase: false, ui_review: true, ui_safety_gate: true } };
    const result = resolveLoopHooks({ point: 'plan:pre', registry: realRegistry, config });
    const uiStep = result.activeHooks.find(h => h.capId === 'ui' && h.kind === 'step');
    assert.strictEqual(uiStep, undefined, 'Expected ui step to be filtered');
  });

  // FIX 4 INVERSION: empty config + real registry → ui-phase IS active (schema default=true)
  test('plan:pre with empty config + real registry → ui-phase step active by default (FIX 4)', () => {
    // realRegistry has configSchema['workflow.ui_phase'].default === true
    // So with no config and no cwd, the schema default kicks in → active
    const result = resolveLoopHooks({ point: 'plan:pre', registry: realRegistry, config: {} });
    const uiStep = result.activeHooks.find(h => h.capId === 'ui' && h.kind === 'step');
    assert.ok(
      uiStep,
      'Expected ui step to be active by default (configSchema.default=true). Got: ' +
        JSON.stringify(result.activeHooks),
    );
    assert.strictEqual(uiStep.when, 'workflow.ui_phase');
  });

  test('execute:wave:post with workflow.ui_safety_gate=true → ui gate active', () => {
    const config = { workflow: { ui_phase: true, ui_review: true, ui_safety_gate: true } };
    const result = resolveLoopHooks({ point: 'execute:wave:post', registry: realRegistry, config });
    const uiGate = result.activeHooks.find(h => h.capId === 'ui' && h.kind === 'gate');
    assert.ok(uiGate, 'Expected ui gate at execute:wave:post');
    assert.strictEqual(uiGate.blocking, true);
    assert.strictEqual(uiGate.onError, 'halt');
  });

  test('execute:wave:post with workflow.ui_safety_gate=false → ui gate filtered', () => {
    const config = { workflow: { ui_phase: true, ui_review: true, ui_safety_gate: false } };
    const result = resolveLoopHooks({ point: 'execute:wave:post', registry: realRegistry, config });
    const uiGate = result.activeHooks.find(h => h.capId === 'ui' && h.kind === 'gate');
    assert.strictEqual(uiGate, undefined, 'Expected ui gate to be filtered');
  });

  // FIX 4: execute:wave:post with empty config → ui gate active by schema default
  test('execute:wave:post with empty config → ui gate active by schema default', () => {
    const result = resolveLoopHooks({ point: 'execute:wave:post', registry: realRegistry, config: {} });
    const uiGate = result.activeHooks.find(h => h.capId === 'ui' && h.kind === 'gate');
    assert.ok(uiGate, 'Expected ui gate active by default (configSchema.default=true)');
    assert.strictEqual(uiGate.blocking, true);
  });
});

// ─── 4. Ordering tests ────────────────────────────────────────────────────────

describe('hook ordering', () => {
  test('steps appear before contributions before gates', () => {
    const registry = makeRegistry({
      point: 'plan:pre',
      steps: [{ capId: 'c1', point: 'plan:pre', ref: { skill: 'sk1' } }],
      contributions: [{ capId: 'c2', point: 'plan:pre', into: 'planner' }],
      gates: { 'plan:pre': [{ capId: 'c3', point: 'plan:pre', check: { query: 'some-gate' }, blocking: false }] },
    });
    const config = {};
    const result = resolveLoopHooks({ point: 'plan:pre', registry, config });
    assert.strictEqual(result.activeHooks.length, 3);
    assert.strictEqual(result.activeHooks[0].kind, 'step');
    assert.strictEqual(result.activeHooks[1].kind, 'contribution');
    assert.strictEqual(result.activeHooks[2].kind, 'gate');
  });

  test('within steps, registry order is preserved', () => {
    const registry = makeRegistry({
      point: 'plan:pre',
      steps: [
        { capId: 'cap-a', point: 'plan:pre', ref: { skill: 'a' } },
        { capId: 'cap-b', point: 'plan:pre', ref: { skill: 'b' } },
        { capId: 'cap-c', point: 'plan:pre', ref: { skill: 'c' } },
      ],
    });
    const result = resolveLoopHooks({ point: 'plan:pre', registry, config: {} });
    assert.deepEqual(result.activeHooks.map(h => h.capId), ['cap-a', 'cap-b', 'cap-c']);
  });
});

// ─── 5. Envelope shape ────────────────────────────────────────────────────────

describe('envelope shape', () => {
  test('envelope has point, activeHooks, rendered from renderLoopHooks', () => {
    const registry = makeRegistry({
      steps: [{ capId: 'cap-a', point: 'plan:pre', ref: { skill: 'my-skill' }, produces: ['A.md'], consumes: ['B.md'] }],
    });
    const resolved = resolveLoopHooks({ point: 'plan:pre', registry, config: {} });
    const rendered = renderLoopHooks(resolved);
    assert.strictEqual(resolved.point, 'plan:pre');
    assert.ok(Array.isArray(resolved.activeHooks));
    assert.strictEqual(typeof rendered, 'string');
  });

  test('empty activeHooks → rendered is non-empty placeholder string', () => {
    const registry = makeRegistry(); // all empty
    const resolved = resolveLoopHooks({ point: 'plan:pre', registry, config: {} });
    const rendered = renderLoopHooks(resolved);
    assert.strictEqual(resolved.activeHooks.length, 0);
    assert.ok(rendered.length > 0, 'rendered should be a non-empty placeholder');
    assert.match(rendered, /plan:pre/);
  });

  test('rendered contains hook content when hooks are active', () => {
    const registry = makeRegistry({
      steps: [{ capId: 'ui', point: 'plan:pre', ref: { skill: 'ui-phase' }, produces: ['UI-SPEC.md'], consumes: ['CONTEXT.md'], when: 'workflow.ui_phase', onError: 'skip' }],
    });
    const config = { workflow: { ui_phase: true } };
    const resolved = resolveLoopHooks({ point: 'plan:pre', registry, config });
    const rendered = renderLoopHooks(resolved);
    assert.match(rendered, /ui-phase/);
    assert.match(rendered, /ui/);
    assert.match(rendered, /UI-SPEC\.md/);
  });

  test('rendered for UI pilot at plan:pre with all flags on', () => {
    const config = { workflow: { ui_phase: true, ui_review: true, ui_safety_gate: true } };
    const resolved = resolveLoopHooks({ point: 'plan:pre', registry: realRegistry, config });
    const rendered = renderLoopHooks(resolved);
    assert.match(rendered, /ui-phase/);
    assert.match(rendered, /UI-SPEC\.md/);
  });
});

// ─── 6. Malformed registry resilience ────────────────────────────────────────

describe('malformed registry resilience', () => {
  test('missing byLoopPoint → no throw, empty activeHooks', () => {
    const badRegistry = {}; // no byLoopPoint
    // No throw — but point validation falls back to CANONICAL_POINTS_FALLBACK
    const result = resolveLoopHooks({ point: 'plan:pre', registry: badRegistry, config: {} });
    assert.strictEqual(result.activeHooks.length, 0);
  });

  test('null hook in steps array → skipped', () => {
    const registry = makeRegistry({
      steps: [null, { capId: 'ok', point: 'plan:pre', ref: { skill: 'ok-skill' } }, undefined],
    });
    const result = resolveLoopHooks({ point: 'plan:pre', registry, config: {} });
    assert.strictEqual(result.activeHooks.length, 1);
    assert.strictEqual(result.activeHooks[0].capId, 'ok');
  });

  test('byLoopPoint[point] missing arrays → no throw, empty result', () => {
    const registry = { byLoopPoint: { 'plan:pre': {} } }; // no steps/contributions/gates keys
    const result = resolveLoopHooks({ point: 'plan:pre', registry, config: {} });
    assert.strictEqual(result.activeHooks.length, 0);
  });

  test('byLoopPoint[point] has non-array steps → treated as empty', () => {
    const registry = { byLoopPoint: { 'plan:pre': { steps: 'bad', contributions: [], gates: [] } } };
    const result = resolveLoopHooks({ point: 'plan:pre', registry, config: {} });
    assert.strictEqual(result.activeHooks.length, 0);
  });

  test('byLoopPoint[point] is null → no throw, empty result', () => {
    const registry = { byLoopPoint: { 'plan:pre': null } };
    const result = resolveLoopHooks({ point: 'plan:pre', registry, config: {} });
    assert.strictEqual(result.activeHooks.length, 0);
  });
});

// ─── 7. Prototype-pollution guard ────────────────────────────────────────────

describe('prototype-pollution guard', () => {
  test('when="__proto__.x" does not pollute Object.prototype', () => {
    const registry = makeRegistry({
      steps: [{ capId: 'attacker', point: 'plan:pre', ref: { skill: 'evil' }, when: '__proto__.x' }],
    });
    const config = { x: 'injected' };
    // Should not throw and should not activate (guard returns found:false)
    const result = resolveLoopHooks({ point: 'plan:pre', registry, config });
    assert.strictEqual(result.activeHooks.length, 0);
    // Object.prototype must not be polluted
    assert.strictEqual(({}).x, undefined);
  });

  test('when="constructor.x" does not pollute', () => {
    const registry = makeRegistry({
      steps: [{ capId: 'attacker', point: 'plan:pre', ref: { skill: 'evil' }, when: 'constructor.x' }],
    });
    const result = resolveLoopHooks({ point: 'plan:pre', registry, config: {} });
    assert.strictEqual(result.activeHooks.length, 0);
  });

  test('when="prototype.x" does not pollute', () => {
    const registry = makeRegistry({
      steps: [{ capId: 'attacker', point: 'plan:pre', ref: { skill: 'evil' }, when: 'prototype.x' }],
    });
    const result = resolveLoopHooks({ point: 'plan:pre', registry, config: {} });
    assert.strictEqual(result.activeHooks.length, 0);
  });

  test('_getNestedConfigValue: __proto__ segment returns found:false', () => {
    const r = _getNestedConfigValue({}, '__proto__.x');
    assert.strictEqual(r.found, false);
  });

  test('_getNestedConfigValue: constructor segment returns found:false', () => {
    const r = _getNestedConfigValue({}, 'constructor.toString');
    assert.strictEqual(r.found, false);
  });

  test('_getNestedConfigValue: normal dotted key traversal works', () => {
    const config = { workflow: { ui_phase: true } };
    const r = _getNestedConfigValue(config, 'workflow.ui_phase');
    assert.strictEqual(r.found, true);
    assert.strictEqual(r.value, true);
  });

  // FIX 4: raw config.json with __proto__ key does not pollute via _readRawConfigKey
  test('raw config.json with "__proto__" key does not pollute Object.prototype', () => {
    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'loop-resolver-proto-'));
    try {
      // Write a raw config.json containing __proto__ at top level and nested
      // (JSON.parse of {"__proto__":{"x":"polluted"}} does NOT set prototype in modern Node,
      // but we verify our guarded traversal returns found:false for such keys)
      const maliciousConfig = '{"__proto__":{"x":"polluted"},"workflow":{"ui_phase":true}}';
      fs.writeFileSync(path.join(tmpDir, 'config.json'), maliciousConfig, 'utf8');
      // _readRawConfigKey with '__proto__.x' should return found:false (guard)
      const r1 = _readRawConfigKey(path.join(tmpDir, 'config.json'), '__proto__.x');
      assert.strictEqual(r1.found, false, '__proto__ lookup must be guarded');
      // Normal key should work
      const r2 = _readRawConfigKey(path.join(tmpDir, 'config.json'), 'workflow.ui_phase');
      assert.strictEqual(r2.found, true);
      assert.strictEqual(r2.value, true);
      // Object.prototype must not be polluted
      assert.strictEqual(({}).x, undefined);
    } finally {
      cleanup(tmpDir);
    }
  });

  // FIX 4: _resolveActivationValue with cwd pointing to project with __proto__ config key
  test('_resolveActivationValue: raw config with __proto__ key does not pollute', () => {
    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'loop-resolver-proto2-'));
    try {
      const planningDir = path.join(tmpDir, '.planning');
      fs.mkdirSync(planningDir, { recursive: true });
      fs.writeFileSync(
        path.join(planningDir, 'config.json'),
        '{"__proto__":{"y":"polluted2"}}',
        'utf8',
      );
      const registry = makeRegistry({
        steps: [{ capId: 'test', point: 'plan:pre', ref: { skill: 'sk' }, when: '__proto__.y' }],
      });
      const result = resolveLoopHooks({ point: 'plan:pre', registry, config: {}, cwd: tmpDir });
      assert.strictEqual(result.activeHooks.length, 0, '__proto__ when must be inactive');
      assert.strictEqual(({}).y, undefined, 'Object.prototype.y must not be polluted');
    } finally {
      cleanup(tmpDir);
    }
  });
});

// ─── 7b. Raw config.json override paths (FIX 4) ──────────────────────────────

describe('raw config.json override paths (FIX 4)', () => {
  // FIX 4: user sets workflow.ui_phase=false in root config.json → hook filtered
  test('root config.json with ui_phase=false overrides schema default=true → inactive', () => {
    // tmpFalseConfigProjectDir has .planning/config.json { workflow: { ui_phase: false } }
    const result = resolveLoopHooks({
      point: 'plan:pre',
      registry: realRegistry,
      config: {}, // empty loadConfig result (simulating pre-cutover)
      cwd: tmpFalseConfigProjectDir,
    });
    const uiStep = result.activeHooks.find(h => h.capId === 'ui' && h.kind === 'step');
    assert.strictEqual(
      uiStep,
      undefined,
      'root config.json override false must beat schema default=true',
    );
  });

  // FIX 4: root config.json with ui_phase=true (explicit) → hook active
  test('root config.json with ui_phase=true → active (raw config read path)', () => {
    // tmpProjectDir has .planning/config.json { workflow: { ui_phase: true } }
    const result = resolveLoopHooks({
      point: 'plan:pre',
      registry: realRegistry,
      config: {}, // empty loadConfig result (simulating pre-cutover)
      cwd: tmpProjectDir,
    });
    const uiStep = result.activeHooks.find(h => h.capId === 'ui' && h.kind === 'step');
    assert.ok(uiStep, 'root config.json ui_phase=true should activate hook');
  });

  // FIX 4: no config.json at all → falls through to schema default=true → active
  test('no config.json → schema default=true → hook active', () => {
    // tmpEmptyProjectDir has .planning/ directory but no config.json
    const result = resolveLoopHooks({
      point: 'plan:pre',
      registry: realRegistry,
      config: {}, // empty loadConfig result
      cwd: tmpEmptyProjectDir,
    });
    const uiStep = result.activeHooks.find(h => h.capId === 'ui' && h.kind === 'step');
    assert.ok(uiStep, 'no config.json → schema default=true → hook should be active');
  });

  // FIX 4: _readRawConfigKey returns found:false for missing file (ENOENT — silent)
  test('_readRawConfigKey: missing file → found:false, no throw', () => {
    const result = _readRawConfigKey('/nonexistent/path/config.json', 'workflow.ui_phase');
    assert.strictEqual(result.found, false);
  });

  // FIX 4: _readRawConfigKey returns found:false for malformed JSON, warns once
  test('_readRawConfigKey: malformed JSON → found:false, no throw', () => {
    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'loop-resolver-malformed-'));
    try {
      const malformedPath = path.join(tmpDir, 'config.json');
      fs.writeFileSync(malformedPath, '{ invalid json }', 'utf8');
      const result = _readRawConfigKey(malformedPath, 'workflow.ui_phase');
      assert.strictEqual(result.found, false, 'malformed JSON should return found:false');
    } finally {
      cleanup(tmpDir);
    }
  });
});

// ─── 8. Renderer tests ────────────────────────────────────────────────────────

describe('renderLoopHooks', () => {
  test('step hook renders skill ref, capId, produces, consumes', () => {
    const resolved = {
      point: 'plan:pre',
      activeHooks: [{
        capId: 'ui',
        kind: 'step',
        ref: { skill: 'ui-phase' },
        when: 'workflow.ui_phase',
        produces: ['UI-SPEC.md'],
        consumes: ['CONTEXT.md'],
        onError: 'skip',
      }],
    };
    const rendered = renderLoopHooks(resolved);
    assert.match(rendered, /Step 1/);
    assert.match(rendered, /skill:ui-phase/);
    assert.match(rendered, /\(ui\)/);
    assert.match(rendered, /UI-SPEC\.md/);
    assert.match(rendered, /CONTEXT\.md/);
    assert.match(rendered, /workflow\.ui_phase/);
    assert.match(rendered, /skip/);
  });

  test('contribution hook renders into role', () => {
    const resolved = {
      point: 'plan:pre',
      activeHooks: [{
        capId: 'contrib-cap',
        kind: 'contribution',
        into: 'planner',
        fragment: { inline: 'Apply the project-specific planning guardrails.' },
      }],
    };
    const rendered = renderLoopHooks(resolved);
    assert.match(rendered, /contribution/);
    assert.match(rendered, /contrib-cap/);
    assert.match(rendered, /planner/);
    assert.match(rendered, /Apply the project-specific planning guardrails\./);
    assert.match(rendered, /<contribution from="contrib-cap" into="planner">/);
    assert.match(rendered, /<\/contribution>/);
    assert.doesNotMatch(rendered, /<contribution[^>]+\/>/);
  });

  test('resolveLoopHooks preserves contribution fragment data', () => {
    const registry = makeRegistry({
      point: 'plan:pre',
      contributions: [{
        capId: 'contrib-cap',
        point: 'plan:pre',
        into: 'planner',
        fragment: { inline: 'Use artifact-backed evidence.' },
        produces: ['PLAN-NOTES.md'],
        consumes: ['CONTEXT.md'],
        when: 'workflow.contrib',
        onError: 'halt',
      }],
      configSchema: {
        'workflow.contrib': { type: 'boolean', default: true, description: 'Enable test contribution.' },
      },
    });
    const resolved = resolveLoopHooks({ point: 'plan:pre', registry, config: {} });
    assert.strictEqual(resolved.activeHooks.length, 1);
    assert.deepEqual(resolved.activeHooks[0].fragment, { inline: 'Use artifact-backed evidence.' });
    assert.deepEqual(resolved.activeHooks[0].produces, ['PLAN-NOTES.md']);
    assert.deepEqual(resolved.activeHooks[0].consumes, ['CONTEXT.md']);
    assert.strictEqual(resolved.activeHooks[0].onError, 'halt');
  });

  test('gate hook renders check, blocking, onError', () => {
    const resolved = {
      point: 'execute:wave:post',
      activeHooks: [{
        capId: 'ui',
        kind: 'gate',
        check: { query: 'ui.safety-gate' },
        blocking: true,
        onError: 'halt',
      }],
    };
    const rendered = renderLoopHooks(resolved);
    assert.match(rendered, /Gate/);
    assert.match(rendered, /ui/);
    assert.match(rendered, /blocking=true/);
    assert.match(rendered, /halt/);
  });

  test('multiple hooks in order render with correct ordinals', () => {
    const resolved = {
      point: 'plan:pre',
      activeHooks: [
        { capId: 'cap-a', kind: 'step', ref: { skill: 'a' }, produces: ['A.md'], consumes: [] },
        { capId: 'cap-b', kind: 'step', ref: { skill: 'b' }, produces: ['B.md'], consumes: ['A.md'] },
      ],
    };
    const rendered = renderLoopHooks(resolved);
    assert.match(rendered, /Step 1/);
    assert.match(rendered, /Step 2/);
    const idx1 = rendered.indexOf('Step 1');
    const idx2 = rendered.indexOf('Step 2');
    assert.ok(idx1 < idx2, 'Step 1 should appear before Step 2');
  });

  test('empty hooks returns placeholder containing the point name', () => {
    const rendered = renderLoopHooks({ point: 'ship:post', activeHooks: [] });
    assert.match(rendered, /ship:post/);
    assert.ok(rendered.length > 0);
  });

  test('rendered is deterministic (same input → same output)', () => {
    const config = { workflow: { ui_phase: true, ui_review: true, ui_safety_gate: true } };
    const resolved = resolveLoopHooks({ point: 'plan:pre', registry: realRegistry, config });
    const r1 = renderLoopHooks(resolved);
    const r2 = renderLoopHooks(resolved);
    assert.strictEqual(r1, r2);
  });
});

// ─── 9. End-to-end cmdLoopRenderHooks (via gsd-tools subprocess) ─────────────

const { spawnSync } = require('node:child_process');
const ROOT = path.resolve(__dirname, '..');
const GSD_TOOLS = path.join(ROOT, 'gsd-core', 'bin', 'gsd-tools.cjs');

describe('cmdLoopRenderHooks end-to-end (via gsd-tools)', () => {
  test('loop render-hooks plan:pre returns JSON envelope with ui-phase step active', () => {
    const result = spawnSync(
      process.execPath,
      [GSD_TOOLS, 'loop', 'render-hooks', 'plan:pre', '--cwd', tmpProjectDir],
      { cwd: ROOT, encoding: 'utf8' },
    );
    assert.strictEqual(result.status, 0, 'Expected exit 0. stderr: ' + (result.stderr || ''));
    const envelope = JSON.parse(result.stdout.trim());
    assert.strictEqual(envelope.point, 'plan:pre');
    assert.ok(Array.isArray(envelope.activeHooks));
    assert.strictEqual(typeof envelope.rendered, 'string');
    // With ui_phase=true in tmpProjectDir config, ui-phase step should be active
    const uiStep = envelope.activeHooks.find(h => h.capId === 'ui' && h.kind === 'step');
    assert.ok(uiStep, 'Expected ui step in activeHooks. Got: ' + JSON.stringify(envelope.activeHooks));
    assert.match(envelope.rendered, /ui-phase/);
  });

  // FIX 4: schema-default activation — no config.json in project → ui-phase step active by default
  test('loop render-hooks plan:pre with no config.json → ui-phase step active by schema default', () => {
    const result = spawnSync(
      process.execPath,
      [GSD_TOOLS, 'loop', 'render-hooks', 'plan:pre', '--cwd', tmpEmptyProjectDir],
      { cwd: ROOT, encoding: 'utf8' },
    );
    assert.strictEqual(result.status, 0, 'Expected exit 0. stderr: ' + (result.stderr || ''));
    const envelope = JSON.parse(result.stdout.trim());
    const uiStep = envelope.activeHooks.find(h => h.capId === 'ui' && h.kind === 'step');
    assert.ok(
      uiStep,
      'Expected ui step active by default. Got: ' + JSON.stringify(envelope.activeHooks),
    );
    assert.match(envelope.rendered, /ui-phase/);
  });

  // FIX 4: explicit false in config.json overrides schema default
  test('loop render-hooks plan:pre with ui_phase=false in config.json → ui-phase step absent', () => {
    const result = spawnSync(
      process.execPath,
      [GSD_TOOLS, 'loop', 'render-hooks', 'plan:pre', '--cwd', tmpFalseConfigProjectDir],
      { cwd: ROOT, encoding: 'utf8' },
    );
    assert.strictEqual(result.status, 0, 'Expected exit 0. stderr: ' + (result.stderr || ''));
    const envelope = JSON.parse(result.stdout.trim());
    const uiStep = envelope.activeHooks.find(h => h.capId === 'ui' && h.kind === 'step');
    assert.strictEqual(
      uiStep,
      undefined,
      'ui-phase step should be absent when config.json sets ui_phase=false',
    );
  });

  test('loop render-hooks invalid-point exits non-zero', () => {
    const result = spawnSync(
      process.execPath,
      [GSD_TOOLS, 'loop', 'render-hooks', 'plan:mid', '--cwd', tmpProjectDir],
      { cwd: ROOT, encoding: 'utf8' },
    );
    assert.notStrictEqual(result.status, 0, 'Expected non-zero exit for invalid point');
    assert.match(result.stderr, /plan:mid|Invalid loop point/);
  });
});