chore(harness): 0.0.6 internals lane run record — PLAN-EVAL cycle 4 surface (not for merge)

.github/scripts/phase-eval-status.mjs

@@ -0,0 +1,59 @@
+/** Prefix reserved for the single lifecycle status label. */
+export const STATUS_PREFIX = 'status:';
+
+/** Terminal status entered before dispatching IMPL-EVAL. */
+export const IMPL_EVAL_STATUS = 'status:impl-eval';
+
+/** GitHub's exact response message when a label is absent from an issue. */
+export const MISSING_LABEL_MESSAGE = 'Label does not exist';
+
+/**
+ * Decide the idempotent status-label transition from a live issue-label set.
+ *
+ * @param {readonly string[]} liveLabels
+ * @returns {{ remove: string[], add: string[] }}
+ */
+export function decideImplEvalStatusTransition(liveLabels) {
+  return {
+    remove: liveLabels.filter((label) => label.startsWith(STATUS_PREFIX)),
+    add: [IMPL_EVAL_STATUS],
+  };
+}
+
+/**
+ * Apply the IMPL-EVAL transition through injected GitHub label operations.
+ *
+ * @param {{
+ *   listLabelsOnIssue: () => Promise<string[]>,
+ *   removeLabel: (label: string) => Promise<void>,
+ *   addLabels: (labels: string[]) => Promise<void>,
+ * }} operations
+ */
+export async function applyImplEvalStatusTransition(operations) {
+  const liveLabels = await operations.listLabelsOnIssue();
+  const decision = decideImplEvalStatusTransition(liveLabels);
+
+  for (const label of decision.remove) {
+    try {
+      await operations.removeLabel(label);
+    } catch (error) {
+      if (!isMissingLabelError(error)) throw error;
+    }
+  }
+
+  await operations.addLabels(decision.add);
+}
+
+/** @param {unknown} error */
+function isMissingLabelError(error) {
+  if (!isRecord(error) || error.status !== 404) return false;
+  const response = error.response;
+  if (!isRecord(response)) return false;
+  const data = response.data;
+  return isRecord(data) && data.message === MISSING_LABEL_MESSAGE;
+}
+
+/** @param {unknown} value */
+function isRecord(value) {
+  return typeof value === 'object' && value !== null;
+}

.github/scripts/phase-eval-status.test.ts

@@ -0,0 +1,166 @@
+import { assertEquals, assertRejects, assertStringIncludes } from '@std/assert';
+import {
+  applyImplEvalStatusTransition,
+  decideImplEvalStatusTransition,
+  IMPL_EVAL_STATUS,
+  MISSING_LABEL_MESSAGE,
+} from './phase-eval-status.mjs';
+
+interface IssueLabelOperations {
+  listLabelsOnIssue(): Promise<string[]>;
+  removeLabel(label: string): Promise<void>;
+  addLabels(labels: string[]): Promise<void>;
+}
+
+function workflowStep(source: string, name: string): string {
+  const lines = source.split('\n');
+  const start = lines.indexOf(`      - name: ${name}`);
+  if (start < 0) throw new Error(`Missing workflow step: ${name}`);
+  let end = lines.length;
+  for (let index = start + 1; index < lines.length; index += 1) {
+    if (lines[index].startsWith('      - name: ')) {
+      end = index;
+      break;
+    }
+  }
+  return lines.slice(start, end).join('\n');
+}
+
+function operations(
+  labels: string[],
+  removeError?: (label: string) => unknown,
+) {
+  const removed: string[] = [];
+  const added: string[][] = [];
+  const client: IssueLabelOperations = {
+    listLabelsOnIssue: () => Promise.resolve(labels),
+    removeLabel: (label: string) => {
+      const error = removeError?.(label);
+      if (error !== undefined) return Promise.reject(error);
+      removed.push(label);
+      return Promise.resolve();
+    },
+    addLabels: (next: string[]) => {
+      added.push(next);
+      return Promise.resolve();
+    },
+  };
+  return { client, removed, added };
+}
+
+Deno.test('race regression: a concurrently removed status label does not fail cleanup', async () => {
+  const { client, removed, added } = operations(
+    ['status:impl', 'area:tooling'],
+    () => ({ status: 404, response: { data: { message: 'Label does not exist' } } }),
+  );
+
+  await applyImplEvalStatusTransition(client);
+
+  assertEquals(removed, []);
+  assertEquals(added, [['status:impl-eval']]);
+});
+
+Deno.test('narrow tolerance: permission failures still fail cleanup', async () => {
+  const { client } = operations(
+    ['status:impl'],
+    () => ({
+      status: 403,
+      response: { data: { message: 'Resource not accessible by integration' } },
+    }),
+  );
+
+  await assertRejects(() => applyImplEvalStatusTransition(client));
+});
+
+Deno.test('narrow tolerance: an unrelated 404 still fails cleanup', async () => {
+  const { client } = operations(
+    ['status:impl'],
+    () => ({ status: 404, response: { data: { message: 'Not Found' } } }),
+  );
+
+  await assertRejects(() => applyImplEvalStatusTransition(client));
+});
+
+Deno.test('terminal decision contains exactly one status label', () => {
+  const decision = decideImplEvalStatusTransition([
+    'type:fix',
+    'status:impl',
+    'status:plan-eval',
+    'area:tooling',
+  ]);
+
+  assertEquals(decision, {
+    remove: ['status:impl', 'status:plan-eval'],
+    add: ['status:impl-eval'],
+  });
+  const terminal = [
+    'type:fix',
+    'area:tooling',
+    ...decision.add,
+  ];
+  assertEquals(terminal.filter((label) => label.startsWith('status:')), ['status:impl-eval']);
+});
+
+Deno.test('generation deduplication remains before trigger creation', async () => {
+  const workflow = await Deno.readTextFile('.github/workflows/openhands-phase-eval.yml');
+  const marker =
+    'const marker = `<!-- openhands-phase-eval generation=${generationEvent.id} phase=${phase} head=${pr.head.sha} -->`;';
+  const claim = "String(comment.body ?? '').includes(marker)";
+  const earlyReturn = 'if (existing) {';
+  const create = 'github.rest.issues.createComment({';
+
+  assertStringIncludes(workflow, marker);
+  assertStringIncludes(workflow, claim);
+  assertStringIncludes(workflow, earlyReturn);
+  assertStringIncludes(workflow, create);
+  assertEquals(workflow.indexOf(marker) < workflow.indexOf(claim), true);
+  assertEquals(workflow.indexOf(claim) < workflow.indexOf(earlyReturn), true);
+  assertEquals(workflow.indexOf(earlyReturn) < workflow.indexOf(create), true);
+});
+
+Deno.test('status bookkeeping failures are attributed and dispatch remains conditionally eligible', async () => {
+  const workflow = await Deno.readTextFile('.github/workflows/openhands-phase-eval.yml');
+  const transition = workflowStep(workflow, 'Enter IMPL-EVAL status on ready transition');
+  const diagnostic = workflowStep(
+    workflow,
+    'Record attributed IMPL-EVAL status-transition failure',
+  );
+  const dispatch = workflowStep(workflow, 'Resolve and dispatch exactly one evaluator');
+
+  assertStringIncludes(transition, 'id: enter_impl_eval_status');
+  assertStringIncludes(transition, 'continue-on-error: true');
+  assertStringIncludes(transition, 'core.setOutput(');
+  assertStringIncludes(transition, "'failure_reason'");
+  assertStringIncludes(diagnostic, "steps.enter_impl_eval_status.outcome == 'failure'");
+  assertStringIncludes(diagnostic, 'evaluator dispatch attempt continues');
+  assertStringIncludes(diagnostic, 'REQUEST_ACTOR: ${{ github.actor }}');
+  assertStringIncludes(diagnostic, 'FAILURE_REASON:');
+  assertStringIncludes(dispatch, '!cancelled()');
+  assertStringIncludes(
+    dispatch,
+    "steps.require_chainable_trigger_token.outcome == 'success'",
+  );
+  assertEquals(dispatch.includes('enter_impl_eval_status.outcome'), false);
+});
+
+Deno.test('inline cleanup transcription matches helper contract literals', async () => {
+  const workflow = await Deno.readTextFile('.github/workflows/openhands-phase-eval.yml');
+  const transition = workflowStep(workflow, 'Enter IMPL-EVAL status on ready transition');
+
+  assertEquals(workflow.includes('Check out trusted phase-eval scripts'), false);
+  assertEquals(transition.includes('await import('), false);
+  assertStringIncludes(transition, 'github.rest.issues.listLabelsOnIssue');
+  assertStringIncludes(
+    transition,
+    `const IMPL_EVAL_STATUS = '${IMPL_EVAL_STATUS}';`,
+  );
+  assertStringIncludes(
+    transition,
+    `const MISSING_LABEL_MESSAGE = '${MISSING_LABEL_MESSAGE}';`,
+  );
+  assertStringIncludes(
+    transition,
+    'error?.response?.data?.message === MISSING_LABEL_MESSAGE',
+  );
+  assertStringIncludes(transition, 'labels: [IMPL_EVAL_STATUS]');
+});