@guilz-dev/sdlc-gh 0.1.0

package/scripts/test-e2e-manifest-scenarios.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import { validateManifest } from "./lib/e2e-manifest.mjs";
+
+const baseManifest = {
+  version: 1,
+  min_tasks: 3,
+  last_rotated: "2026-07-04T00:00:00Z",
+  tasks: [
+    { id: "e2e-001", class: "docs" },
+    { id: "e2e-002", class: "test-fix" },
+    { id: "e2e-003", class: "refactor" },
+  ],
+};
+
+const ok = validateManifest(baseManifest, ["e2e-001", "e2e-002", "e2e-003"]);
+assert.equal(ok.errors.length, 0);
+
+const duplicate = validateManifest(
+  {
+    ...baseManifest,
+    tasks: [
+      { id: "e2e-001", class: "docs" },
+      { id: "e2e-001", class: "docs" },
+      { id: "e2e-002", class: "test-fix" },
+    ],
+  },
+  ["e2e-001", "e2e-002"],
+);
+assert.ok(duplicate.errors.some((e) => e.includes("Duplicate")));
+
+const missingFile = validateManifest(baseManifest, ["e2e-001", "e2e-002"]);
+assert.ok(missingFile.errors.some((e) => e.includes("Missing task file")));
+
+const orphan = validateManifest(baseManifest, ["e2e-001", "e2e-002", "e2e-003", "e2e-099"]);
+assert.ok(orphan.errors.some((e) => e.includes("Orphan")));
+
+const unsupported = validateManifest(
+  {
+    ...baseManifest,
+    tasks: [{ id: "e2e-001", class: "unknown-class" }],
+  },
+  ["e2e-001"],
+);
+assert.ok(unsupported.errors.some((e) => e.includes("Unsupported")));
+
+const belowMin = validateManifest(
+  { ...baseManifest, min_tasks: 5, tasks: [{ id: "e2e-001", class: "docs" }] },
+  ["e2e-001"],
+);
+assert.ok(belowMin.errors.some((e) => e.includes("at least 5")));
+
+const missingRotation = validateManifest(
+  { ...baseManifest, last_rotated: undefined },
+  ["e2e-001", "e2e-002", "e2e-003"],
+);
+assert.ok(missingRotation.errors.some((e) => e.includes("last_rotated")));
+
+const invalidRotation = validateManifest(
+  { ...baseManifest, last_rotated: "not-a-date" },
+  ["e2e-001", "e2e-002", "e2e-003"],
+);
+assert.ok(invalidRotation.errors.some((e) => e.includes("invalid last_rotated")));
+
+console.log("E2E manifest scenario tests passed");

package/scripts/test-gh-aw-dogfood-scenarios.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import {
+  buildDogfoodReport,
+  DOGFOOD_TASK_LABEL,
+  evaluateDogfoodScope,
+  findOutOfScopePaths,
+  isDogfoodAllowedPath,
+  parseGhAwLockMetadata,
+  parseGhAwWorkflowMarkdown,
+  validateGhAwSourceSections,
+  validateSafeOutputs,
+} from "./lib/gh-aw-dogfood.mjs";
+import { readFileSync } from "node:fs";
+
+assert.equal(DOGFOOD_TASK_LABEL, "task:gh-aw-dogfood");
+assert.equal(isDogfoodAllowedPath(".github/workflows/nightly-harness-review.md"), true);
+assert.equal(isDogfoodAllowedPath(".github/labels.yml"), true);
+assert.equal(isDogfoodAllowedPath("src/app.ts"), false);
+assert.deepEqual(findOutOfScopePaths(["docs/gh-aw-dogfood.md", "src/x.ts"]), ["src/x.ts"]);
+
+const scopeWithoutLabel = evaluateDogfoodScope(
+  [".github/labels.yml", "src/x.ts"],
+  [],
+);
+assert.equal(scopeWithoutLabel.ok, true);
+assert.equal(scopeWithoutLabel.enforced, false);
+
+const scopeWithLabel = evaluateDogfoodScope(["src/x.ts"], [DOGFOOD_TASK_LABEL]);
+assert.equal(scopeWithLabel.ok, false);
+assert.equal(scopeWithLabel.enforced, true);
+
+const nightlyMd = readFileSync(".github/workflows/nightly-harness-review.md", "utf8");
+const parsed = parseGhAwWorkflowMarkdown(nightlyMd);
+assert.ok(parsed?.fields?.["safe-outputs"]);
+assert.equal(validateSafeOutputs(parsed.fields).ok, true);
+assert.equal(validateGhAwSourceSections(nightlyMd, "nightly-harness-review").ok, true);
+assert.ok(parsed.fields["safe-outputs"]["create-issue"]);
+
+const redteamMd = readFileSync(".github/workflows/weekly-redteam.md", "utf8");
+const redteam = parseGhAwWorkflowMarkdown(redteamMd);
+assert.equal(validateSafeOutputs(redteam.fields).ok, true);
+assert.equal(validateGhAwSourceSections(redteamMd, "weekly-redteam").ok, true);
+assert.ok(redteam.fields["safe-outputs"]["create-issue"]);
+assert.equal(redteam.fields["safe-outputs"]["create-pull-request"], undefined);
+
+const lockMeta = parseGhAwLockMetadata(
+  readFileSync(".github/workflows/nightly-harness-review.lock.yml", "utf8"),
+);
+assert.equal(lockMeta?.compiler_version, "v0.81.6");
+
+const bad = validateSafeOutputs({
+  "safe-outputs": { "create-pull-request": { max: 5 } },
+});
+assert.equal(bad.ok, false);
+
+const report = buildDogfoodReport({
+  scope: { ok: true, issues: [] },
+  safeOutputs: { nightly: { ok: true, issues: [] } },
+  compile: { ok: true, skipped: true, issues: [] },
+  lockDrift: { ok: true, issues: [] },
+});
+assert.equal(report.pass, true);
+assert.ok(report.criteria.reviewability.pass);
+
+const reportCompileSkipped = buildDogfoodReport({
+  scope: { ok: true, issues: [] },
+  safeOutputs: { nightly: { ok: true, issues: [] } },
+  compile: { ok: false, skipped: true, issues: ["gh aw CLI not available"] },
+  lockDrift: { ok: true, issues: [] },
+});
+assert.equal(reportCompileSkipped.pass, true);
+
+console.log("gh-aw-dogfood scenarios ok");

package/scripts/test-harness-review-routing-scenarios.mjs

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import {
+  applyRoutingPlanDryRun,
+  bodyHasRoutingMarker,
+  buildIssueAction,
+  buildRoutingPlan,
+  hasRepeatedFfFindings,
+  hasRepeatedWallFindings,
+  inferRoutingScope,
+  ISSUE_KIND,
+  routingDedupeKey,
+  routingMarker,
+} from "./lib/harness-review-routing.mjs";
+
+const sample = JSON.parse(
+  readFileSync("infra/samples/harness-review-summary.json", "utf8"),
+);
+
+assert.equal(hasRepeatedFfFindings(sample), true);
+assert.equal(hasRepeatedWallFindings(sample), false);
+
+const plan = buildRoutingPlan(sample);
+assert.equal(plan.actions.length, 1);
+assert.equal(plan.actions[0].kind, ISSUE_KIND.HARNESS_REVISION);
+assert.ok(plan.actions[0].body.includes(routingMarker(plan.actions[0].dedupe_key)));
+assert.equal(plan.actions[0].scope, "task:test-fix|wall:lint");
+
+const wallSummary = {
+  ...sample,
+  classifications: [
+    ...sample.classifications,
+    {
+      repo: "org/product",
+      task_id: "9",
+      pr_number: 103,
+      classification: "壁不足",
+      rationale: "Harness CI passed while review_outcome is changes_requested",
+      wall_failure_types: [],
+      max_retry_count: 0,
+    },
+  ],
+  rollup: {
+    ...sample.rollup,
+    by_classification: { ...sample.rollup.by_classification, 壁不足: 2 },
+    review_rejection_proxy_count: 1,
+  },
+};
+const wallPlan = buildRoutingPlan(wallSummary);
+assert.equal(wallPlan.actions.length, 2);
+assert.ok(wallPlan.actions.some((a) => a.kind === ISSUE_KIND.WALL_ADDITION));
+
+const singleFf = {
+  ...sample,
+  classifications: [sample.classifications[1]],
+  rollup: {
+    ...sample.rollup,
+    repeated_failure_signatures: [],
+    by_classification: { FF不足: 1 },
+  },
+};
+assert.equal(buildRoutingPlan(singleFf).actions.length, 0);
+assert.ok(buildRoutingPlan(singleFf).skipped.length >= 1);
+
+assert.equal(inferRoutingScope(sample.classifications), "tasks:docs+test-fix");
+
+const dedupeKey = routingDedupeKey(
+  "org/product",
+  ISSUE_KIND.HARNESS_REVISION,
+  "lint",
+  "task:test-fix|wall:lint",
+);
+const action = plan.actions[0];
+assert.equal(bodyHasRoutingMarker(action.body, dedupeKey), true);
+assert.ok(action.title.includes("task:test-fix|wall:lint"));
+
+const dry = applyRoutingPlanDryRun(plan, {
+  existingIssues: [{ number: 99, body: action.body }],
+});
+assert.equal(dry.results[0].operation, "update_issue");
+assert.equal(dry.results[0].issue_number, 99);
+
+const lintOnlySignature = {
+  ...sample,
+  classifications: [sample.classifications[0]],
+  rollup: {
+    ...sample.rollup,
+    by_classification: { モデル限界: 1 },
+    repeated_failure_signatures: [
+      { wall_failure_type: "lint", record_count: 2, task_count: 1, task_ids: ["42"] },
+    ],
+  },
+};
+assert.equal(hasRepeatedFfFindings(lintOnlySignature), true);
+const lintOnlyPlan = buildRoutingPlan(lintOnlySignature);
+assert.equal(lintOnlyPlan.actions.length, 0);
+assert.ok(
+  lintOnlyPlan.skipped.some((s) => s.reason.includes("without FF不足 classification")),
+);
+
+const otherScopeSummary = {
+  ...sample,
+  classifications: [
+    {
+      ...sample.classifications[1],
+      task_id: "55",
+      pr_number: 222,
+      task_class: "docs",
+    },
+    {
+      ...sample.classifications[1],
+      task_id: "56",
+      pr_number: 223,
+      task_class: "docs",
+    },
+  ],
+  rollup: {
+    ...sample.rollup,
+    by_classification: { FF不足: 2 },
+    repeated_failure_signatures: [
+      { wall_failure_type: "lint", record_count: 2, task_count: 2, task_ids: ["55", "56"] },
+    ],
+  },
+};
+const otherScopePlan = buildRoutingPlan(otherScopeSummary);
+assert.equal(otherScopePlan.actions[0].scope, "task:docs|wall:lint");
+assert.notEqual(otherScopePlan.actions[0].dedupe_key, plan.actions[0].dedupe_key);
+
+console.log("harness-review-routing scenarios ok");

package/scripts/test-harness-review-scenarios.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import {
+  buildHarnessReviewSummary,
+  classifyTaskGroup,
+  dedupeTelemetryRecords,
+  formatHarnessReviewMarkdown,
+} from "./lib/harness-review.mjs";
+
+function artifact(overrides) {
+  const payload = {
+    task_id: "42",
+    pr_number: 101,
+    repo: "org/product",
+    task_class: "docs",
+    autonomy_level: "L1",
+    retry_count: 0,
+    wall_failure_type: "",
+    final_outcome: "in_progress",
+    review_outcome: "pending",
+    ...overrides.payload,
+  };
+  return {
+    schema_version: "1",
+    emitted_at: overrides.emitted_at ?? "2026-07-04T12:00:00.000Z",
+    source: overrides.source ?? "harness-ci",
+    workflow_run_id: overrides.workflow_run_id ?? 1,
+    payload,
+  };
+}
+
+const deduped = dedupeTelemetryRecords([
+  artifact({ workflow_run_id: 1, source: "harness-ci" }),
+  artifact({ workflow_run_id: 1, source: "harness-ci", emitted_at: "2026-07-04T13:00:00.000Z" }),
+  artifact({ workflow_run_id: 2, source: "harness-ci", payload: { pr_number: 102 } }),
+]);
+assert.equal(deduped.length, 2);
+
+const modelLimit = classifyTaskGroup([
+  artifact({
+    source: "agent-retry-orchestrator",
+    payload: { retry_count: 3, wall_failure_type: "test", final_outcome: "escalated" },
+  }),
+]);
+assert.equal(modelLimit?.classification, "モデル限界");
+
+const wallGap = classifyTaskGroup([
+  artifact({ source: "harness-ci", payload: { wall_failure_type: "" } }),
+  artifact({
+    source: "pr-context",
+    payload: { review_outcome: "changes_requested", wall_failure_type: "" },
+  }),
+]);
+assert.equal(wallGap?.classification, "壁不足");
+
+const ffGap = classifyTaskGroup([
+  artifact({ workflow_run_id: 10, source: "harness-ci", payload: { wall_failure_type: "lint" } }),
+  artifact({
+    workflow_run_id: 11,
+    source: "agent-retry-orchestrator",
+    payload: { wall_failure_type: "lint", retry_count: 1 },
+  }),
+]);
+assert.equal(ffGap?.classification, "FF不足");
+
+const repeatedTest = classifyTaskGroup([
+  artifact({ workflow_run_id: 20, source: "harness-ci", payload: { wall_failure_type: "test" } }),
+  artifact({ workflow_run_id: 21, source: "harness-ci", payload: { wall_failure_type: "test" } }),
+]);
+assert.equal(repeatedTest?.classification, "モデル限界");
+
+const summary = buildHarnessReviewSummary([
+  artifact({
+    source: "agent-retry-orchestrator",
+    payload: { retry_count: 3, wall_failure_type: "test", final_outcome: "escalated" },
+  }),
+  artifact({
+    source: "harness-ci",
+    payload: { pr_number: 200, task_id: "55", wall_failure_type: "" },
+  }),
+  artifact({
+    source: "pr-context",
+    payload: { pr_number: 200, task_id: "55", review_outcome: "changes_requested" },
+  }),
+]);
+assert.equal(summary.rollup.failure_groups, 2);
+assert.equal(summary.rollup.by_classification["モデル限界"], 1);
+assert.equal(summary.rollup.by_classification["壁不足"], 1);
+assert.match(formatHarnessReviewMarkdown(summary), /Nightly harness review/);
+assert.ok(Array.isArray(summary.rollup.repeated_failure_signatures));
+
+console.log("harness-review scenarios ok");

package/scripts/test-hooks-scenarios.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+/**
+ * Reject/allow scenario tests for hooks.json patterns (Phase 2 static gate).
+ */
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+const hooksPath = join(process.cwd(), ".github/hooks/hooks.json");
+if (!existsSync(hooksPath)) {
+  console.error("hooks.json not found");
+  process.exit(1);
+}
+
+const { hooks } = JSON.parse(readFileSync(hooksPath, "utf8"));
+const blockPatterns = hooks
+  .filter((h) => h.action === "block" && h.pattern)
+  .map((h) => new RegExp(h.pattern, "i"));
+
+const mustBlock = [
+  "git push --force",
+  "git push -f origin main",
+  "rm -rf /",
+  "DROP TABLE users",
+];
+
+const mustAllow = ["git status", "npm test", "pytest -q"];
+
+for (const cmd of mustBlock) {
+  const blocked = blockPatterns.some((re) => re.test(cmd));
+  if (!blocked) {
+    console.error(`::error::Expected block for: ${cmd}`);
+    process.exit(1);
+  }
+}
+
+for (const cmd of mustAllow) {
+  const blocked = blockPatterns.some((re) => re.test(cmd));
+  if (blocked) {
+    console.error(`::error::Unexpected block for: ${cmd}`);
+    process.exit(1);
+  }
+}
+
+console.log("Hooks scenario tests passed");

package/scripts/test-issue-form-label-sync-scenarios.mjs

@@ -0,0 +1,48 @@
+import assert from "node:assert/strict";
+import { parseTaskIssueSelections, planIssueLabels } from "./lib/issue-form-label-sync.mjs";
+
+const taskIssueBody = `### Goal
+
+Tighten docs.
+
+### Task class
+
+docs
+
+### Max autonomy level
+
+L1
+`;
+
+const parsed = parseTaskIssueSelections(taskIssueBody);
+assert.equal(parsed.isTaskIssue, true);
+assert.equal(parsed.taskClass, "docs");
+assert.equal(parsed.autonomy, "L1");
+assert.equal(parsed.taskLabel, "task:docs");
+assert.equal(parsed.autonomyLabel, "autonomy:L1");
+
+const plan = planIssueLabels(["bug", "task:infra", "autonomy:L0"], parsed);
+assert.deepEqual(plan.labels, ["bug", "task:docs", "autonomy:L1"]);
+assert.equal(plan.changed, true);
+
+const alreadySynced = planIssueLabels(["bug", "task:docs", "autonomy:L1"], parsed);
+assert.equal(alreadySynced.changed, false);
+
+const invalid = parseTaskIssueSelections(`### Goal
+
+Test
+
+### Task class
+
+custom
+
+### Max autonomy level
+
+L9
+`);
+const invalidPlan = planIssueLabels(["bug"], invalid);
+assert.equal(invalidPlan.changed, false);
+assert.deepEqual(invalidPlan.labels, ["bug"]);
+
+const nonTask = parseTaskIssueSelections("plain issue body");
+assert.equal(nonTask.isTaskIssue, false);