@1aboveio/skills 1.0.8 → 1.0.9

package/skills/engineering/harness-runtime/harness-runtime.test.mjs

@@ -1,967 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import {
-  CapabilityUnavailableError,
-  HarnessRuntimeError,
-  HARNESS_RUNTIME_ERROR_CODES,
-  QUESTION_ADAPTER_PRIORITY,
-  QUESTION_FALLBACK_POLICY,
-  UnsupportedQuestionError,
-  defineCurrentTurnCapabilities,
-  defineModelAvailability,
-  defineQuestionAnswers,
-  defineQuestionSpec,
-  normalizeQuestionResponses,
-  planStructuredQuestions,
-} from './index.mjs';
-
-const RUNTIME_DIR = dirname(fileURLToPath(import.meta.url));
-const QUESTION_RESPONSE_FIXTURES = JSON.parse(readFileSync(
-  join(RUNTIME_DIR, 'fixtures', 'question-responses.json'),
-  'utf8',
-));
-const NATIVE_QUESTION_SCHEMAS = JSON.parse(readFileSync(
-  join(RUNTIME_DIR, 'fixtures', 'native-question-schemas.json'),
-  'utf8',
-));
-
-// @covers package:harness-runtime
-// @level unit
-test('current-turn capabilities preserve only explicitly advertised native tools and spawn models', () => {
-  const input = {
-    nativeTools: ['ask_user_question', 'functions'],
-    spawnModelIds: ['openai/gpt-a', 'anthropic/model-b'],
-  };
-  const capabilities = defineCurrentTurnCapabilities(input);
-
-  assert.deepEqual(capabilities, input);
-  assert.ok(Object.isFrozen(capabilities));
-  assert.ok(Object.isFrozen(capabilities.nativeTools));
-  assert.ok(Object.isFrozen(capabilities.spawnModelIds));
-  input.nativeTools.push('inferred-tool');
-  assert.deepEqual(capabilities.nativeTools, ['ask_user_question', 'functions']);
-
-  assert.throws(
-    () => defineCurrentTurnCapabilities({ nativeTools: ['same', 'same'], spawnModelIds: [] }),
-    (error) => error instanceof HarnessRuntimeError
-      && error.code === HARNESS_RUNTIME_ERROR_CODES.INVALID_CAPABILITIES,
-  );
-});
-
-// @covers package:harness-runtime
-// @level unit
-test('neutral questions and answers retain stable ids without selecting a native adapter', () => {
-  const question = defineQuestionSpec({
-    id: 'delivery-mode',
-    header: 'Delivery',
-    prompt: 'How should this unit be delivered?',
-    options: [
-      { id: 'queue', label: 'Merge queue', description: 'Use the protected queue.' },
-      { id: 'direct', label: 'Direct PR', description: 'Leave the PR merge-ready.' },
-    ],
-    recommendationOrder: ['queue', 'direct'],
-    multiSelect: false,
-    secret: false,
-  });
-  const answers = defineQuestionAnswers({ 'delivery-mode': ['queue'] });
-
-  assert.equal(question.id, 'delivery-mode');
-  assert.deepEqual(question.recommendationOrder, ['queue', 'direct']);
-  assert.deepEqual(answers, { 'delivery-mode': ['queue'] });
-  assert.ok(Object.isFrozen(question.options[0]));
-  assert.ok(Object.isFrozen(answers['delivery-mode']));
-
-  assert.throws(
-    () => defineQuestionSpec({
-      id: 'duplicate-options',
-      header: 'Duplicate',
-      prompt: 'Choose.',
-      options: [{ id: 'same', label: 'One' }, { id: 'same', label: 'Two' }],
-    }),
-    (error) => error instanceof HarnessRuntimeError
-      && error.code === HARNESS_RUNTIME_ERROR_CODES.INVALID_QUESTION,
-  );
-  assert.throws(
-    () => defineQuestionAnswers({ 'delivery-mode': [] }),
-    (error) => error instanceof HarnessRuntimeError
-      && error.code === HARNESS_RUNTIME_ERROR_CODES.INVALID_ANSWERS,
-  );
-});
-
-// @covers package:harness-runtime
-// @level unit
-test('model availability states its harness and completeness without claiming static config is full', () => {
-  const availability = defineModelAvailability({
-    harness: 'codex',
-    completeness: 'partial',
-    models: [
-      { id: 'openai/gpt-a', sources: ['current-turn'] },
-      { id: 'openai/gpt-b', sources: ['credentials', 'config'] },
-    ],
-  });
-
-  assert.deepEqual(availability, {
-    harness: 'codex',
-    completeness: 'partial',
-    models: [
-      { id: 'openai/gpt-a', sources: ['current-turn'] },
-      { id: 'openai/gpt-b', sources: ['credentials', 'config'] },
-    ],
-  });
-  assert.ok(Object.isFrozen(availability.models[0].sources));
-  assert.throws(
-    () => defineModelAvailability({
-      harness: 'codex',
-      completeness: 'full',
-      models: [{ id: 'openai/gpt-a', sources: ['config'] }],
-    }),
-    (error) => error instanceof HarnessRuntimeError
-      && error.code === HARNESS_RUNTIME_ERROR_CODES.INVALID_MODEL_AVAILABILITY,
-  );
-});
-
-// @covers package:harness-runtime
-// @level unit
-test('capability failures and fallback policy forbid textual multiple-choice emulation', () => {
-  assert.deepEqual(QUESTION_FALLBACK_POLICY, {
-    noNativeQuestionTool: {
-      freeText: 'concise-free-text-only',
-      multipleChoice: 'forbidden',
-    },
-    unsupportedMultiSelect: 'error',
-    secretInput: 'error',
-  });
-  assert.ok(Object.isFrozen(QUESTION_FALLBACK_POLICY.noNativeQuestionTool));
-
-  const unavailable = new CapabilityUnavailableError('native-question-tool', {
-    availableTools: ['functions'],
-  });
-  assert.equal(unavailable.code, HARNESS_RUNTIME_ERROR_CODES.CAPABILITY_UNAVAILABLE);
-  assert.equal(unavailable.capability, 'native-question-tool');
-  assert.deepEqual(unavailable.details.availableTools, ['functions']);
-
-  const unsupported = new UnsupportedQuestionError('secret-input', { questionId: 'token' });
-  assert.equal(unsupported.code, HARNESS_RUNTIME_ERROR_CODES.UNSUPPORTED_QUESTION);
-  assert.equal(unsupported.reason, 'secret-input');
-});
-
-function plannerQuestion(id, overrides = {}) {
-  return {
-    id,
-    header: 'Delivery',
-    prompt: `How should ${id} proceed?`,
-    options: [
-      { id: 'direct', label: 'Direct', description: 'Proceed directly.' },
-      { id: 'queue', label: 'Queue', description: 'Use the merge queue.' },
-    ],
-    recommendationOrder: ['queue', 'direct'],
-    multiSelect: false,
-    secret: false,
-    ...overrides,
-  };
-}
-
-// @covers package:harness-runtime
-// @level unit
-test('Pi planning is capability-driven, ordered, validated, and deterministically batched', () => {
-  assert.deepEqual(QUESTION_ADAPTER_PRIORITY, [
-    'ask_user_question',
-    'request_user_input',
-    'AskUserQuestion',
-  ]);
-  const capabilities = defineCurrentTurnCapabilities({
-    nativeTools: ['AskUserQuestion', 'request_user_input', 'functions', 'ask_user_question'],
-    spawnModelIds: [],
-  });
-  const questions = Array.from({ length: 5 }, (_, index) => plannerQuestion(`gate-${index + 1}`));
-  const plan = planStructuredQuestions(capabilities, questions);
-
-  assert.equal(plan.kind, 'native');
-  assert.equal(plan.adapter, 'pi');
-  assert.equal(plan.toolName, 'ask_user_question');
-  assert.equal(plan.capacity, 4);
-  assert.equal(plan.requiresMultipleCalls, true);
-  assert.deepEqual(plan.batching, {
-    required: true,
-    reason: 'adapter-capacity',
-    callCount: 2,
-  });
-  assert.deepEqual(plan.calls.map((call) => call.questionIds), [
-    ['gate-1', 'gate-2', 'gate-3', 'gate-4'],
-    ['gate-5'],
-  ]);
-  assert.deepEqual(plan.calls[0].payload.questions[0], {
-    question: 'How should gate-1 proceed?',
-    header: 'Delivery',
-    options: [
-      { label: 'Queue', description: 'Use the merge queue.' },
-      { label: 'Direct', description: 'Proceed directly.' },
-    ],
-    multiSelect: false,
-  });
-  assert.ok(Object.isFrozen(plan.calls[0].payload.questions[0].options[0]));
-
-  assert.throws(
-    () => planStructuredQuestions(capabilities, [plannerQuestion('same'), plannerQuestion('same')]),
-    (error) => error instanceof HarnessRuntimeError
-      && error.code === HARNESS_RUNTIME_ERROR_CODES.INVALID_QUESTION
-      && error.details.reason === 'duplicate-question-id',
-  );
-  assert.throws(
-    () => planStructuredQuestions(capabilities, [plannerQuestion('long-header', { header: 'x'.repeat(17) })]),
-    (error) => error instanceof UnsupportedQuestionError
-      && error.reason === 'header-too-long',
-  );
-  assert.throws(
-    () => planStructuredQuestions(capabilities, [plannerQuestion('long-label', {
-      options: [
-        { id: 'long', label: 'x'.repeat(61), description: 'Too long.' },
-        { id: 'short', label: 'Short', description: 'Short.' },
-      ],
-      recommendationOrder: [],
-    })]),
-    (error) => error instanceof UnsupportedQuestionError
-      && error.reason === 'option-label-too-long',
-  );
-});
-
-// @covers package:harness-runtime
-// @level unit
-test('Codex planning wins fixed priority and emits stable ids in deterministic groups of three', () => {
-  const capabilities = defineCurrentTurnCapabilities({
-    nativeTools: ['AskUserQuestion', 'request_user_input'],
-    spawnModelIds: [],
-  });
-  const questions = Array.from({ length: 4 }, (_, index) => plannerQuestion(`gate_${index + 1}`));
-  const plan = planStructuredQuestions(capabilities, questions);
-
-  assert.equal(plan.adapter, 'codex');
-  assert.equal(plan.toolName, 'request_user_input');
-  assert.equal(plan.capacity, 3);
-  assert.equal(plan.requiresMultipleCalls, true);
-  assert.deepEqual(plan.calls.map((call) => call.questionIds), [
-    ['gate_1', 'gate_2', 'gate_3'],
-    ['gate_4'],
-  ]);
-  assert.deepEqual(plan.calls[0].payload.questions[0], {
-    id: 'gate_1',
-    header: 'Delivery',
-    question: 'How should gate_1 proceed?',
-    options: [
-      { label: 'Queue (Recommended)', description: 'Use the merge queue.' },
-      { label: 'Direct', description: 'Proceed directly.' },
-    ],
-  });
-  assert.deepEqual(plan.calls[0].answerMappings[0].options, [
-    { id: 'queue', label: 'Queue (Recommended)' },
-    { id: 'direct', label: 'Direct' },
-  ]);
-  assert.throws(
-    () => planStructuredQuestions(capabilities, [plannerQuestion('not-stable')]),
-    (error) => error instanceof UnsupportedQuestionError
-      && error.reason === 'invalid-question-id',
-  );
-  assert.throws(
-    () => planStructuredQuestions(capabilities, [plannerQuestion('multi', { multiSelect: true })]),
-    (error) => error instanceof UnsupportedQuestionError
-      && error.reason === 'multi-select',
-  );
-});
-
-// @covers package:harness-runtime
-// @level unit
-// @fails-without-fix package:harness-runtime
-test('Codex rejects recommendation suffix collisions before emitting native labels', () => {
-  const capabilities = defineCurrentTurnCapabilities({
-    nativeTools: ['request_user_input'],
-    spawnModelIds: [],
-  });
-
-  assert.throws(
-    () => planStructuredQuestions(capabilities, [plannerQuestion('delivery', {
-      options: [
-        { id: 'queue', label: 'Queue', description: 'Use the merge queue.' },
-        {
-          id: 'literal_suffix',
-          label: 'Queue (Recommended)',
-          description: 'Keep the literal suffix.',
-        },
-      ],
-      recommendationOrder: ['queue'],
-    })]),
-    (error) => error instanceof HarnessRuntimeError
-      && error.code === HARNESS_RUNTIME_ERROR_CODES.INVALID_QUESTION
-      && error.details.reason === 'native-option-label-collision'
-      && error.details.adapter === 'codex'
-      && error.details.questionId === 'delivery'
-      && error.details.label === 'Queue (Recommended)'
-      && error.details.optionIds.join(',') === 'queue,literal_suffix',
-  );
-});
-
-// @covers package:harness-runtime
-// @level unit
-// @fails-without-fix package:harness-runtime
-test('Claude Code rejects multi-select answer-format collisions before emission', () => {
-  const capabilities = defineCurrentTurnCapabilities({
-    nativeTools: ['AskUserQuestion'],
-    spawnModelIds: [],
-  });
-
-  assert.throws(
-    () => planStructuredQuestions(capabilities, [plannerQuestion('features', {
-      multiSelect: true,
-      options: [
-        { id: 'a', label: 'A', description: 'Select A.' },
-        { id: 'b', label: 'B', description: 'Select B.' },
-        { id: 'combined', label: 'A, B', description: 'Select the literal combined label.' },
-      ],
-      recommendationOrder: [],
-    })]),
-    (error) => error instanceof HarnessRuntimeError
-      && error.code === HARNESS_RUNTIME_ERROR_CODES.INVALID_QUESTION
-      && error.details.reason === 'native-answer-format-collision'
-      && error.details.adapter === 'claude-code'
-      && error.details.questionId === 'features'
-      && error.details.answer === 'A, B',
-  );
-});
-
-// @covers package:harness-runtime
-// @level unit
-// @fails-without-fix package:harness-runtime
-test('normalization never guesses duplicate labels and preserves custom answers', () => {
-  const piPlan = planStructuredQuestions(
-    defineCurrentTurnCapabilities({ nativeTools: ['ask_user_question'], spawnModelIds: [] }),
-    [plannerQuestion('delivery', {
-      options: [
-        { id: 'long', label: 'x'.repeat(60), description: 'Exact native maximum.' },
-        { id: 'queue', label: 'Queue', description: 'Use the merge queue.' },
-      ],
-      recommendationOrder: ['queue'],
-    })],
-  );
-  assert.equal(piPlan.calls[0].payload.questions[0].options[1].label.length, 60);
-  assert.deepEqual(normalizeQuestionResponses(piPlan, [{
-    details: {
-      answers: [{
-        questionIndex: 0,
-        question: 'How should delivery proceed?',
-        kind: 'custom',
-        answer: 'Queue',
-      }],
-      cancelled: false,
-    },
-  }]), { delivery: ['Queue'] });
-
-  for (const nativeTool of ['request_user_input', 'AskUserQuestion']) {
-    const plan = planStructuredQuestions(
-      defineCurrentTurnCapabilities({ nativeTools: [nativeTool], spawnModelIds: [] }),
-      [plannerQuestion('delivery')],
-    );
-    const response = nativeTool === 'request_user_input'
-      ? { answers: { delivery: { answers: ['Ship after lunch'] } } }
-      : { answers: { 'How should delivery proceed?': 'Ship after lunch' } };
-    assert.deepEqual(normalizeQuestionResponses(plan, [response]), {
-      delivery: ['Ship after lunch'],
-    });
-  }
-
-  const malformedPlan = structuredClone(planStructuredQuestions(
-    defineCurrentTurnCapabilities({ nativeTools: ['request_user_input'], spawnModelIds: [] }),
-    [plannerQuestion('delivery')],
-  ));
-  malformedPlan.calls[0].answerMappings[0].options[1].label = 'Queue (Recommended)';
-  assert.throws(
-    () => normalizeQuestionResponses(malformedPlan, [{
-      answers: { delivery: { answers: ['Queue (Recommended)'] } },
-    }]),
-    (error) => error instanceof HarnessRuntimeError
-      && error.code === HARNESS_RUNTIME_ERROR_CODES.INVALID_ANSWERS
-      && error.details.reason === 'ambiguous-option-label'
-      && error.details.questionId === 'delivery'
-      && error.details.optionIds.join(',') === 'queue,direct',
-  );
-});
-
-// @covers package:harness-runtime
-// @level unit
-test('Claude Code planning uses native field names and groups four questions per call', () => {
-  const capabilities = defineCurrentTurnCapabilities({
-    nativeTools: ['AskUserQuestion'],
-    spawnModelIds: [],
-  });
-  const questions = Array.from({ length: 5 }, (_, index) => plannerQuestion(`gate-${index + 1}`, {
-    multiSelect: index === 0,
-  }));
-  const plan = planStructuredQuestions(capabilities, questions);
-
-  assert.equal(plan.adapter, 'claude-code');
-  assert.equal(plan.toolName, 'AskUserQuestion');
-  assert.equal(plan.capacity, 4);
-  assert.equal(plan.requiresMultipleCalls, true);
-  assert.deepEqual(plan.calls.map((call) => call.questionIds), [
-    ['gate-1', 'gate-2', 'gate-3', 'gate-4'],
-    ['gate-5'],
-  ]);
-  assert.deepEqual(plan.calls[0].payload.questions[0], {
-    question: 'How should gate-1 proceed?',
-    header: 'Delivery',
-    options: [
-      { label: 'Queue', description: 'Use the merge queue.' },
-      { label: 'Direct', description: 'Proceed directly.' },
-    ],
-    multiSelect: true,
-  });
-});
-
-// @covers package:harness-runtime
-// @level unit
-test('no-adapter planning distinguishes concise free text from forbidden textual choices', () => {
-  const capabilities = defineCurrentTurnCapabilities({
-    nativeTools: ['functions'],
-    spawnModelIds: [],
-  });
-  const freeText = planStructuredQuestions(capabilities, [plannerQuestion('context', {
-    prompt: 'What context is missing?',
-    options: [],
-    recommendationOrder: [],
-  })]);
-  assert.deepEqual(freeText, {
-    kind: 'fallback',
-    adapter: null,
-    reason: 'no-supported-native-question-tool',
-    decision: 'concise-free-text',
-    freeText: {
-      allowed: true,
-      questionId: 'context',
-      prompt: 'What context is missing?',
-    },
-    textualMultipleChoice: {
-      allowed: false,
-      reason: 'forbidden',
-    },
-    availableTools: ['functions'],
-  });
-  assert.ok(Object.isFrozen(freeText.freeText));
-
-  const forbidden = planStructuredQuestions(capabilities, [plannerQuestion('delivery')]);
-  assert.equal(forbidden.kind, 'fallback');
-  assert.equal(forbidden.decision, 'textual-multiple-choice-forbidden');
-  assert.deepEqual(forbidden.freeText, {
-    allowed: false,
-    reason: 'logical-question-has-options',
-  });
-  const multipleFreeText = planStructuredQuestions(capabilities, [
-    plannerQuestion('first_context', { options: [], recommendationOrder: [] }),
-    plannerQuestion('second_context', { options: [], recommendationOrder: [] }),
-  ]);
-  assert.deepEqual(multipleFreeText.freeText, {
-    allowed: false,
-    reason: 'multiple-questions',
-  });
-  assert.deepEqual(forbidden.textualMultipleChoice, {
-    allowed: false,
-    reason: 'forbidden',
-  });
-
-  assert.throws(
-    () => planStructuredQuestions(capabilities, [plannerQuestion('token', {
-      options: [],
-      recommendationOrder: [],
-      secret: true,
-    })]),
-    (error) => error instanceof UnsupportedQuestionError
-      && error.reason === 'secret-input',
-  );
-  assert.throws(
-    () => planStructuredQuestions(capabilities, [plannerQuestion('features', {
-      options: [],
-      recommendationOrder: [],
-      multiSelect: true,
-    })]),
-    (error) => error instanceof UnsupportedQuestionError
-      && error.reason === 'multi-select',
-  );
-});
-
-// @covers package:harness-runtime
-// @level unit
-test('native adapters enforce exact capacities, field limits, and option invariants', () => {
-  const adapters = [
-    { tool: 'ask_user_question', capacity: 4, headerLimit: 16, optionLimit: 4 },
-    { tool: 'request_user_input', capacity: 3, headerLimit: 12, optionLimit: 3 },
-    { tool: 'AskUserQuestion', capacity: 4, headerLimit: 12, optionLimit: 4 },
-  ];
-  for (const { tool, capacity, headerLimit, optionLimit } of adapters) {
-    const capabilities = defineCurrentTurnCapabilities({ nativeTools: [tool], spawnModelIds: [] });
-    const exactCapacity = Array.from({ length: capacity }, (_, index) =>
-      plannerQuestion(`gate_${index + 1}`, { header: 'x'.repeat(headerLimit) }));
-    const plan = planStructuredQuestions(capabilities, exactCapacity);
-    assert.deepEqual(plan.batching, { required: false, reason: null, callCount: 1 });
-
-    const maximumOptions = Array.from({ length: optionLimit }, (_, index) => ({
-      id: `choice_${index + 1}`,
-      label: `Choice ${index + 1}`,
-      description: `Choose ${index + 1}.`,
-    }));
-    assert.equal(planStructuredQuestions(capabilities, [plannerQuestion('options', {
-      options: maximumOptions,
-      recommendationOrder: [],
-    })]).kind, 'native');
-    assert.throws(
-      () => planStructuredQuestions(capabilities, [plannerQuestion('too_many', {
-        options: [...maximumOptions, {
-          id: 'overflow',
-          label: 'Overflow',
-          description: 'Exceeds the native limit.',
-        }],
-        recommendationOrder: [],
-      })]),
-      (error) => error instanceof UnsupportedQuestionError && error.reason === 'option-count',
-    );
-    assert.throws(
-      () => planStructuredQuestions(capabilities, [plannerQuestion('long_header', {
-        header: 'x'.repeat(headerLimit + 1),
-      })]),
-      (error) => error instanceof UnsupportedQuestionError && error.reason === 'header-too-long',
-    );
-    assert.throws(
-      () => planStructuredQuestions(capabilities, [plannerQuestion('duplicate_label', {
-        options: [
-          { id: 'first', label: 'Same', description: 'First.' },
-          { id: 'second', label: 'Same', description: 'Second.' },
-        ],
-        recommendationOrder: [],
-      })]),
-      (error) => error instanceof HarnessRuntimeError
-        && error.details.reason === 'duplicate-option-label',
-    );
-    assert.throws(
-      () => planStructuredQuestions(capabilities, [plannerQuestion('description', {
-        options: [
-          { id: 'first', label: 'First' },
-          { id: 'second', label: 'Second', description: 'Second.' },
-        ],
-        recommendationOrder: [],
-      })]),
-      (error) => error instanceof UnsupportedQuestionError
-        && error.reason === 'option-description-required',
-    );
-  }
-});
-
-// @covers package:harness-runtime
-// @level unit
-test('malformed neutral specs and unsupported native inputs fail before invocation', () => {
-  const capabilities = defineCurrentTurnCapabilities({
-    nativeTools: ['ask_user_question'],
-    spawnModelIds: [],
-  });
-  for (const questions of [null, []]) {
-    assert.throws(
-      () => planStructuredQuestions(capabilities, questions),
-      (error) => error instanceof HarnessRuntimeError
-        && error.details.reason === 'empty-question-batch',
-    );
-  }
-  assert.throws(
-    () => planStructuredQuestions(capabilities, [plannerQuestion('duplicate_options', {
-      options: [
-        { id: 'same', label: 'First', description: 'First.' },
-        { id: 'same', label: 'Second', description: 'Second.' },
-      ],
-      recommendationOrder: [],
-    })]),
-    (error) => error instanceof HarnessRuntimeError
-      && error.code === HARNESS_RUNTIME_ERROR_CODES.INVALID_QUESTION,
-  );
-  assert.throws(
-    () => planStructuredQuestions(capabilities, [plannerQuestion('recommendation', {
-      recommendationOrder: ['missing'],
-    })]),
-    (error) => error instanceof HarnessRuntimeError
-      && error.code === HARNESS_RUNTIME_ERROR_CODES.INVALID_QUESTION,
-  );
-  assert.throws(
-    () => planStructuredQuestions(capabilities, [plannerQuestion('boolean', {
-      multiSelect: 'yes',
-    })]),
-    (error) => error instanceof HarnessRuntimeError
-      && error.code === HARNESS_RUNTIME_ERROR_CODES.INVALID_QUESTION,
-  );
-  for (const nativeTool of QUESTION_ADAPTER_PRIORITY) {
-    const nativeCapabilities = defineCurrentTurnCapabilities({
-      nativeTools: [nativeTool],
-      spawnModelIds: [],
-    });
-    assert.throws(
-      () => planStructuredQuestions(nativeCapabilities, [plannerQuestion('empty', {
-        options: [],
-        recommendationOrder: [],
-      })]),
-      (error) => error instanceof UnsupportedQuestionError
-        && error.reason === 'option-count',
-    );
-    assert.throws(
-      () => planStructuredQuestions(nativeCapabilities, [plannerQuestion('secret', { secret: true })]),
-      (error) => error instanceof UnsupportedQuestionError
-        && error.reason === 'secret-input',
-    );
-  }
-});
-
-// @covers package:harness-runtime
-// @level unit
-test('all native response fixtures normalize selected labels and custom text to neutral ids', () => {
-  const adapters = [
-    { adapter: 'pi', nativeTool: 'ask_user_question' },
-    { adapter: 'codex', nativeTool: 'request_user_input' },
-    { adapter: 'claude-code', nativeTool: 'AskUserQuestion' },
-  ];
-  for (const { adapter, nativeTool } of adapters) {
-    const plan = planStructuredQuestions(
-      defineCurrentTurnCapabilities({ nativeTools: [nativeTool], spawnModelIds: [] }),
-      [plannerQuestion('delivery'), plannerQuestion('context')],
-    );
-    const answers = normalizeQuestionResponses(plan, [QUESTION_RESPONSE_FIXTURES[adapter].success]);
-    assert.deepEqual(answers, {
-      delivery: ['queue'],
-      context: ['After lunch'],
-    });
-    assert.ok(Object.isFrozen(answers));
-    assert.ok(Object.isFrozen(answers.delivery));
-  }
-});
-
-// @covers package:harness-runtime
-// @level unit
-test('Pi and Claude multi-select responses normalize to the same option-id arrays', () => {
-  for (const [adapter, nativeTool] of [
-    ['pi', 'ask_user_question'],
-    ['claude-code', 'AskUserQuestion'],
-  ]) {
-    const plan = planStructuredQuestions(
-      defineCurrentTurnCapabilities({ nativeTools: [nativeTool], spawnModelIds: [] }),
-      [plannerQuestion('features', { multiSelect: true })],
-    );
-    assert.deepEqual(
-      normalizeQuestionResponses(plan, [QUESTION_RESPONSE_FIXTURES[adapter].multi]),
-      { features: ['queue', 'direct'] },
-    );
-  }
-});
-
-// @covers package:harness-runtime
-// @level unit
-test('cancellation discards partial gates and malformed native responses fail closed', () => {
-  for (const [adapter, nativeTool] of [
-    ['pi', 'ask_user_question'],
-    ['codex', 'request_user_input'],
-    ['claude-code', 'AskUserQuestion'],
-  ]) {
-    const plan = planStructuredQuestions(
-      defineCurrentTurnCapabilities({ nativeTools: [nativeTool], spawnModelIds: [] }),
-      [plannerQuestion('delivery')],
-    );
-    assert.deepEqual(
-      normalizeQuestionResponses(plan, [QUESTION_RESPONSE_FIXTURES[adapter].cancelled]),
-      {},
-    );
-  }
-
-  const batchedPiPlan = planStructuredQuestions(
-    defineCurrentTurnCapabilities({ nativeTools: ['ask_user_question'], spawnModelIds: [] }),
-    Array.from({ length: 5 }, (_, index) => plannerQuestion(`gate-${index + 1}`)),
-  );
-  const completedFirstCall = {
-    details: {
-      answers: batchedPiPlan.calls[0].answerMappings.map((mapping, questionIndex) => ({
-        questionIndex,
-        question: mapping.prompt,
-        kind: 'option',
-        answer: 'Queue',
-      })),
-      cancelled: false,
-    },
-  };
-  assert.deepEqual(normalizeQuestionResponses(batchedPiPlan, [
-    completedFirstCall,
-    QUESTION_RESPONSE_FIXTURES.pi.cancelled,
-  ]), {});
-
-  const codexPlan = planStructuredQuestions(
-    defineCurrentTurnCapabilities({ nativeTools: ['request_user_input'], spawnModelIds: [] }),
-    [plannerQuestion('delivery')],
-  );
-  assert.throws(
-    () => normalizeQuestionResponses(codexPlan, [{
-      answers: { unknown: { answers: ['Queue'] } },
-    }]),
-    (error) => error instanceof HarnessRuntimeError
-      && error.code === HARNESS_RUNTIME_ERROR_CODES.INVALID_ANSWERS,
-  );
-  assert.throws(
-    () => normalizeQuestionResponses(codexPlan, [{
-      answers: { delivery: { answers: [] } },
-    }]),
-    (error) => error instanceof HarnessRuntimeError
-      && error.code === HARNESS_RUNTIME_ERROR_CODES.INVALID_ANSWERS,
-  );
-});
-
-// @covers package:harness-runtime
-// @level unit
-test('malformed and incomplete native responses fail closed', () => {
-  const plans = Object.fromEntries([
-    ['pi', 'ask_user_question'],
-    ['codex', 'request_user_input'],
-    ['claude-code', 'AskUserQuestion'],
-  ].map(([adapter, tool]) => [adapter, planStructuredQuestions(
-    defineCurrentTurnCapabilities({ nativeTools: [tool], spawnModelIds: [] }),
-    [plannerQuestion('delivery'), plannerQuestion('context')],
-  )]));
-
-  assert.throws(
-    () => normalizeQuestionResponses({}, []),
-    (error) => error instanceof HarnessRuntimeError
-      && error.details.reason === 'invalid-question-plan',
-  );
-  for (const responses of [null, []]) {
-    assert.throws(
-      () => normalizeQuestionResponses(plans.pi, responses),
-      (error) => error instanceof HarnessRuntimeError
-        && error.details.reason === 'response-count',
-    );
-  }
-  const malformedResponses = [
-    [plans.pi, {}],
-    [plans.pi, { details: { answers: [
-      {
-        questionIndex: 0,
-        question: 'How should delivery proceed?',
-        kind: 'option',
-        answer: 'Queue',
-      },
-      {
-        questionIndex: 0,
-        question: 'How should delivery proceed?',
-        kind: 'option',
-        answer: 'Queue',
-      },
-    ], cancelled: false } }],
-    [plans.pi, { details: { answers: [{
-      questionIndex: 0,
-      question: 'How should delivery proceed?',
-      kind: 'multi',
-      selected: ['Queue'],
-    }], cancelled: false } }],
-    [plans.pi, { details: { answers: [{
-      questionIndex: 0,
-      question: 'How should delivery proceed?',
-      kind: 'option',
-      answer: 'Missing option',
-    }], cancelled: false } }],
-    [plans.pi, { details: { answers: [{
-      questionIndex: 0,
-      question: 'How should delivery proceed?',
-      kind: 'custom',
-      answer: '',
-    }], cancelled: false } }],
-    [plans.pi, { details: { answers: [{
-      questionIndex: 0,
-      question: 'Wrong prompt',
-      kind: 'option',
-      answer: 'Queue',
-    }], cancelled: false } }],
-    [plans.pi, { details: { answers: [{
-      questionIndex: 0,
-      question: 'How should delivery proceed?',
-      kind: 'unknown',
-      answer: 'Queue',
-    }], cancelled: false } }],
-    [plans.codex, {}],
-    [plans.codex, { answers: { delivery: { answers: [''] } } }],
-    [plans.codex, { answers: { delivery: { answers: ['Queue (Recommended)', 'Direct'] } } }],
-    [plans['claude-code'], {}],
-    [plans['claude-code'], { answers: { 'Unknown prompt': 'Queue' } }],
-  ];
-  for (const [plan, response] of malformedResponses) {
-    assert.throws(
-      () => normalizeQuestionResponses(plan, [response]),
-      (error) => error instanceof HarnessRuntimeError
-        && error.code === HARNESS_RUNTIME_ERROR_CODES.INVALID_ANSWERS,
-    );
-  }
-
-  const partialResponses = [
-    [plans.pi, { details: { answers: [{
-      questionIndex: 0,
-      question: 'How should delivery proceed?',
-      kind: 'option',
-      answer: 'Queue',
-    }], cancelled: false } }],
-    [plans.codex, { answers: { delivery: { answers: ['Queue'] } } }],
-    [plans['claude-code'], { answers: { 'How should delivery proceed?': 'Queue' } }],
-  ];
-  for (const [plan, response] of partialResponses) {
-    assert.throws(
-      () => normalizeQuestionResponses(plan, [response]),
-      (error) => error instanceof HarnessRuntimeError
-        && error.details.reason === 'incomplete-native-response',
-    );
-  }
-
-  assert.throws(
-    () => planStructuredQuestions(
-      defineCurrentTurnCapabilities({ nativeTools: ['AskUserQuestion'], spawnModelIds: [] }),
-      [plannerQuestion('ambiguous', {
-        multiSelect: true,
-        options: [
-          { id: 'a', label: 'A', description: 'A.' },
-          { id: 'b', label: 'B', description: 'B.' },
-          { id: 'combined', label: 'A, B', description: 'Combined.' },
-        ],
-        recommendationOrder: [],
-      })],
-    ),
-    (error) => error instanceof HarnessRuntimeError
-      && error.details.reason === 'native-answer-format-collision',
-  );
-
-  const duplicatePlan = structuredClone(planStructuredQuestions(
-    defineCurrentTurnCapabilities({ nativeTools: ['ask_user_question'], spawnModelIds: [] }),
-    Array.from({ length: 5 }, (_, index) => plannerQuestion(`gate-${index + 1}`)),
-  ));
-  duplicatePlan.calls[1].answerMappings[0].questionId = 'gate-1';
-  const duplicateResponses = duplicatePlan.calls.map((call) => ({
-    details: {
-      answers: call.answerMappings.map((mapping, questionIndex) => ({
-        questionIndex,
-        question: mapping.prompt,
-        kind: 'option',
-        answer: 'Queue',
-      })),
-      cancelled: false,
-    },
-  }));
-  assert.throws(
-    () => normalizeQuestionResponses(duplicatePlan, duplicateResponses),
-    (error) => error instanceof HarnessRuntimeError
-      && error.details.reason === 'duplicate-question-answer',
-  );
-});
-
-// @covers package:harness-runtime
-// @level unit
-test('malformed prompt and Pi sentinel collisions are rejected before native invocation', () => {
-  const capabilities = defineCurrentTurnCapabilities({
-    nativeTools: ['ask_user_question'],
-    spawnModelIds: [],
-  });
-  assert.throws(
-    () => planStructuredQuestions(capabilities, [
-      plannerQuestion('first', { prompt: 'Same prompt?' }),
-      plannerQuestion('second', { prompt: 'Same prompt?' }),
-    ]),
-    (error) => error instanceof HarnessRuntimeError
-      && error.code === HARNESS_RUNTIME_ERROR_CODES.INVALID_QUESTION
-      && error.details.reason === 'duplicate-question-prompt',
-  );
-  for (const [index, label] of NATIVE_QUESTION_SCHEMAS.pi.reservedLabels.entries()) {
-    assert.throws(
-      () => planStructuredQuestions(capabilities, [plannerQuestion(`reserved-${index}`, {
-        options: [
-          { id: 'reserved', label, description: 'Conflicts with native UI.' },
-          { id: 'direct', label: 'Direct', description: 'Proceed directly.' },
-        ],
-        recommendationOrder: [],
-      })]),
-      (error) => error instanceof UnsupportedQuestionError
-        && error.reason === 'reserved-option-label',
-    );
-  }
-});
-
-// @covers package:harness-runtime
-// @level integration
-test('pinned native schemas and Codex operator docs separate configuration from capability', () => {
-  assert.equal(NATIVE_QUESTION_SCHEMAS.pi.questions.maximum, 4);
-  assert.equal(NATIVE_QUESTION_SCHEMAS.codex.questions.maximum, 3);
-  assert.equal(NATIVE_QUESTION_SCHEMAS.codex.recommendationLabelSuffix, ' (Recommended)');
-  assert.equal(NATIVE_QUESTION_SCHEMAS['claude-code'].questions.maximum, 4);
-  const contracts = readFileSync(join(RUNTIME_DIR, 'native-question-contracts.md'), 'utf8');
-  const codexDocs = readFileSync(join(RUNTIME_DIR, '..', '..', '..', 'agents', 'systems', 'codex.md'), 'utf8');
-  assert.match(contracts, /current-turn nativeTools/);
-  assert.match(contracts, /secret input/i);
-  assert.match(contracts, /textual multiple-choice/i);
-  for (const label of NATIVE_QUESTION_SCHEMAS.pi.reservedLabels) assert.match(contracts, new RegExp(label.replace('.', '\\.')));
-  for (const schema of Object.values(NATIVE_QUESTION_SCHEMAS)) assert.match(contracts, new RegExp(schema.toolName));
-
-  const packageContracts = readFileSync(join(RUNTIME_DIR, 'contracts.md'), 'utf8');
-  for (const name of [
-    'defineCurrentTurnCapabilities',
-    'defineQuestionSpec',
-    'defineQuestionAnswers',
-    'defineModelAvailability',
-    'planStructuredQuestions',
-    'normalizeQuestionResponses',
-    'discover-models.mjs',
-    'model-catalog.mjs',
-  ]) assert.match(packageContracts, new RegExp(name.replace('.', '\\.')));
-
-  const catalogPath = join(RUNTIME_DIR, 'references', 'model-catalog.md');
-  const catalog = readFileSync(catalogPath, 'utf8');
-  for (const match of catalog.matchAll(/\[[^\]]+\]\(([^)]+)\)/g)) {
-    if (/^(?:https?:|#)/.test(match[1])) continue;
-    assert.ok(existsSync(resolve(dirname(catalogPath), match[1])), `broken model-catalog.md link: ${match[1]}`);
-  }
-  assert.doesNotMatch(catalog, /SKILL\.md pre-flight|\[pre-flight\.md\]\(pre-flight\.md\)/);
-
-  assert.match(codexDocs, /default_mode_request_user_input = true/);
-  assert.match(codexDocs, /does not prove.*available/i);
-  assert.match(codexDocs, /current-turn tool list/i);
-});
-
-function runConsumer(script) {
-  return spawnSync(process.execPath, [script], { encoding: 'utf8' });
-}
-
-// @covers package:harness-runtime
-// @level integration
-test('the same consumer specifier resolves harness-runtime in nested source and flat installs', () => {
-  const root = mkdtempSync(join(tmpdir(), 'harness-runtime-resolution-'));
-  try {
-    const layouts = [
-      {
-        runtime: join(root, 'source', 'skills', 'engineering', 'harness-runtime'),
-        consumer: join(root, 'source', 'skills', 'engineering', 'resolve-issues', 'scripts', 'consumer.mjs'),
-      },
-      {
-        runtime: join(root, 'flat', 'harness-runtime'),
-        consumer: join(root, 'flat', 'resolve-issues', 'scripts', 'consumer.mjs'),
-      },
-    ];
-    for (const layout of layouts) {
-      cpSync(RUNTIME_DIR, layout.runtime, { recursive: true });
-      mkdirSync(dirname(layout.consumer), { recursive: true });
-      writeFileSync(layout.consumer, [
-        "import { defineCurrentTurnCapabilities } from '../../harness-runtime/index.mjs';",
-        "const value = defineCurrentTurnCapabilities({ nativeTools: ['native'], spawnModelIds: ['model'] });",
-        'process.stdout.write(JSON.stringify(value));',
-        '',
-      ].join('\n'));
-      const result = runConsumer(layout.consumer);
-      assert.equal(result.status, 0, result.stderr);
-      assert.deepEqual(JSON.parse(result.stdout), { nativeTools: ['native'], spawnModelIds: ['model'] });
-    }
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});