p-dev-harness 0.3.0 → 0.3.1

package/workspace-snapshot/files/tests/p-dev/workspace-snapshot-policy.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from "vitest";
+import {
+  isForbiddenSnapshotPath,
+  isIncludedSnapshotPath,
+  normalizeSnapshotPath,
+  WORKSPACE_SNAPSHOT_POLICY,
+} from "../../src/p-dev/workspace-snapshot-policy.js";
+
+describe("workspace snapshot policy", () => {
+  it("includes curated workspace roots and excludes generated package outputs", () => {
+    expect(isIncludedSnapshotPath("src/p-dev/main.ts")).toBe(true);
+    expect(isIncludedSnapshotPath(".agents/skills/planner/SKILL.md")).toBe(true);
+    expect(isIncludedSnapshotPath("packages/p-dev/package.json")).toBe(true);
+    expect(isIncludedSnapshotPath("packages/p-dev/bin/p-dev.js")).toBe(false);
+    expect(isIncludedSnapshotPath("packages/p-dev/workspace-snapshot/manifest.json")).toBe(
+      false,
+    );
+    expect(isForbiddenSnapshotPath(".env.local")).toBe(true);
+    expect(isForbiddenSnapshotPath("node_modules/foo")).toBe(true);
+    expect(
+      isForbiddenSnapshotPath("docs/releases/v0.3.1-provisioning-evidence.md"),
+    ).toBe(true);
+  });
+
+  it("normalizes snapshot paths", () => {
+    expect(normalizeSnapshotPath("./src/index.ts")).toBe("src/index.ts");
+    expect(() => normalizeSnapshotPath("../secret")).toThrow(/Invalid snapshot path/);
+  });
+
+  it("declares required top-level paths", () => {
+    expect(WORKSPACE_SNAPSHOT_POLICY.requiredPaths).toContain("src");
+    expect(WORKSPACE_SNAPSHOT_POLICY.requiredPaths).toContain(".agents");
+    expect(WORKSPACE_SNAPSHOT_POLICY.requiredPaths).toContain("tests");
+  });
+});

package/workspace-snapshot/files/tests/p-dev/workspace-snapshot-validation.test.ts

@@ -0,0 +1,158 @@
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { computeSnapshotFileSha256 } from "../../src/p-dev/workspace-snapshot-digest.js";
+import { parseWorkspaceSnapshotManifestJson } from "../../src/p-dev/workspace-snapshot-manifest.js";
+import {
+  validateEmbeddedSnapshotFiles,
+  validateSnapshotFileEntry,
+} from "../../src/p-dev/workspace-snapshot-validation.js";
+import {
+  buildTestWorkspaceSnapshotManifest,
+  createTestWorkspaceSnapshotRoot,
+  TEST_SNAPSHOT_README_CONTENT,
+  TEST_SNAPSHOT_README_PATH,
+} from "../setup/test-workspace-snapshot-fixture.js";
+
+describe("workspace-snapshot-validation", () => {
+  let packageRoot = "";
+
+  afterEach(async () => {
+    if (packageRoot) {
+      await import("node:fs/promises").then(({ rm }) =>
+        rm(packageRoot, { recursive: true, force: true }),
+      );
+      packageRoot = "";
+    }
+  });
+
+  it("accepts a valid embedded snapshot fixture", async () => {
+    const fixture = await createTestWorkspaceSnapshotRoot("0.3.0");
+    packageRoot = fixture.packageRoot;
+    const result = await validateEmbeddedSnapshotFiles({
+      snapshotRoot: fixture.snapshotRoot,
+      manifest: fixture.manifest,
+    });
+    expect(result).toEqual({ ok: true });
+  });
+
+  it.each([
+    ["file bytes", async (fixture: Awaited<ReturnType<typeof createTestWorkspaceSnapshotRoot>>) => {
+      await writeFile(
+        path.join(fixture.snapshotRoot, "files", TEST_SNAPSHOT_README_PATH),
+        Buffer.from("# tampered\n"),
+      );
+    }],
+    [
+      "declared size",
+      async (fixture: Awaited<ReturnType<typeof createTestWorkspaceSnapshotRoot>>) => {
+        fixture.manifest.files[0] = {
+          ...fixture.manifest.files[0],
+          size: fixture.manifest.files[0].size + 1,
+        };
+      },
+    ],
+    [
+      "SHA-256",
+      async (fixture: Awaited<ReturnType<typeof createTestWorkspaceSnapshotRoot>>) => {
+        fixture.manifest.files[0] = {
+          ...fixture.manifest.files[0],
+          sha256: "0".repeat(64),
+        };
+      },
+    ],
+    [
+      "git blob SHA",
+      async (fixture: Awaited<ReturnType<typeof createTestWorkspaceSnapshotRoot>>) => {
+        fixture.manifest.files[0] = {
+          ...fixture.manifest.files[0],
+          gitBlobSha1: "0".repeat(40),
+        };
+      },
+    ],
+    [
+      "root-tree SHA",
+      async (fixture: Awaited<ReturnType<typeof createTestWorkspaceSnapshotRoot>>) => {
+        fixture.manifest.gitRootTreeSha1 = "0".repeat(40);
+      },
+    ],
+    [
+      "snapshot digest",
+      async (fixture: Awaited<ReturnType<typeof createTestWorkspaceSnapshotRoot>>) => {
+        fixture.manifest.snapshotSha256 = "0".repeat(64);
+      },
+    ],
+    [
+      "mode",
+      async (fixture: Awaited<ReturnType<typeof createTestWorkspaceSnapshotRoot>>) => {
+        fixture.manifest.files[0] = {
+          ...fixture.manifest.files[0],
+          mode: "120000",
+          type: "file",
+        };
+      },
+    ],
+    [
+      "type",
+      async (fixture: Awaited<ReturnType<typeof createTestWorkspaceSnapshotRoot>>) => {
+        fixture.manifest.files[0] = {
+          ...fixture.manifest.files[0],
+          type: "symlink",
+          mode: "100644",
+        };
+      },
+    ],
+    [
+      "package version content ID",
+      async (fixture: Awaited<ReturnType<typeof createTestWorkspaceSnapshotRoot>>) => {
+        fixture.manifest.snapshotContentId = "0".repeat(64);
+      },
+    ],
+    [
+      "duplicate path",
+      async (fixture: Awaited<ReturnType<typeof createTestWorkspaceSnapshotRoot>>) => {
+        fixture.manifest.files.push({ ...fixture.manifest.files[0] });
+      },
+    ],
+    [
+      "non-canonical path",
+      async (fixture: Awaited<ReturnType<typeof createTestWorkspaceSnapshotRoot>>) => {
+        fixture.manifest.files[0] = {
+          ...fixture.manifest.files[0],
+          path: "./README.md",
+        };
+      },
+    ],
+  ])("rejects tampered snapshot: %s", async (_label, mutate) => {
+    const fixture = await createTestWorkspaceSnapshotRoot("0.3.0");
+    packageRoot = fixture.packageRoot;
+    await mutate(fixture);
+    const result = await validateEmbeddedSnapshotFiles({
+      snapshotRoot: fixture.snapshotRoot,
+      manifest: fixture.manifest,
+    });
+    expect(result.ok).toBe(false);
+  });
+
+  it("rejects unsupported generation version in manifest parsing", () => {
+    const manifest = buildTestWorkspaceSnapshotManifest("0.3.0");
+    manifest.generation.version = 99;
+    const parsed = parseWorkspaceSnapshotManifestJson(JSON.stringify(manifest));
+    expect(parsed.ok).toBe(false);
+  });
+
+  it("rejects forbidden snapshot paths", () => {
+    const manifest = buildTestWorkspaceSnapshotManifest("0.3.0");
+    manifest.files.push({
+      path: ".env.local",
+      type: "file",
+      mode: "100644",
+      size: 1,
+      sha256: computeSnapshotFileSha256(Buffer.from("x")),
+      gitBlobSha1: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+    });
+    const result = validateSnapshotFileEntry(manifest.files[1]);
+    expect(result.ok).toBe(false);
+  });
+});

package/workspace-snapshot/files/tests/p-dev/workspace.test.ts

@@ -0,0 +1,80 @@
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  isPathInsidePackageInstall,
+  resolveWorkspaceDir,
+  seedWorkspaceTemplates,
+} from "../../src/p-dev/workspace.js";
+
+describe("p-dev workspace", () => {
+  let tempRoot = "";
+
+  beforeEach(async () => {
+    tempRoot = await mkdtemp(path.join(tmpdir(), "p-dev-workspace-"));
+  });
+
+  afterEach(async () => {
+    await rm(tempRoot, { recursive: true, force: true });
+  });
+
+  it("prefers cli workspace over env and default", () => {
+    expect(
+      resolveWorkspaceDir({
+        cliWorkspace: "/tmp/cli",
+        envWorkspace: "/tmp/env",
+        homeDir: "/tmp/home",
+      }),
+    ).toEqual({ workspaceDir: path.resolve("/tmp/cli"), source: "cli" });
+
+    expect(
+      resolveWorkspaceDir({
+        envWorkspace: "/tmp/env",
+        homeDir: "/tmp/home",
+      }),
+    ).toEqual({ workspaceDir: path.resolve("/tmp/env"), source: "env" });
+
+    expect(resolveWorkspaceDir({ homeDir: "/tmp/home" })).toEqual({
+      workspaceDir: path.join("/tmp/home", ".p-dev"),
+      source: "default",
+    });
+  });
+
+  it("seeds templates without overwriting existing files", async () => {
+    const workspaceDir = path.join(tempRoot, "workspace");
+    const templatesDir = path.join(tempRoot, "templates");
+    await mkdir(path.join(templatesDir, ".harness"), { recursive: true });
+    await writeFile(
+      path.join(templatesDir, ".env.example"),
+      "HARNESS_CONFIG_PATH=.harness/config.local.json\n",
+      "utf8",
+    );
+    await writeFile(
+      path.join(templatesDir, ".harness", "config.example.json"),
+      '{"version":1}\n',
+      "utf8",
+    );
+
+    const first = await seedWorkspaceTemplates({ workspaceDir, templatesDir });
+    expect(first.seeded).toHaveLength(2);
+
+    await writeFile(
+      path.join(workspaceDir, ".env.local"),
+      "LINEAR_API_KEY=existing\n",
+      "utf8",
+    );
+
+    const second = await seedWorkspaceTemplates({ workspaceDir, templatesDir });
+    expect(second.seeded).toHaveLength(0);
+    expect(second.skipped).toHaveLength(2);
+    expect(await readFile(path.join(workspaceDir, ".env.local"), "utf8")).toBe(
+      "LINEAR_API_KEY=existing\n",
+    );
+  });
+
+  it("detects paths inside the package install directory", () => {
+    expect(isPathInsidePackageInstall("/pkg/gui", "/pkg")).toBe(true);
+    expect(isPathInsidePackageInstall("/tmp/workspace", "/pkg")).toBe(false);
+  });
+});

package/workspace-snapshot/files/tests/preview/production-from-merge.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import {
+  extractProductionUrlFromComments,
+  extractProductionUrlFromChecks,
+  inferVercelReadyFromComments,
+} from "../../src/preview/production-from-merge.js";
+
+describe("production-from-merge", () => {
+  it("detects Vercel Ready in PR comments", () => {
+    expect(
+      inferVercelReadyFromComments([
+        {
+          author: "vercel[bot]",
+          body: "| Project | Deployment |\n| x | ![Ready](https://vercel.com/static/status/ready.svg) [Ready](https://vercel.com) |",
+        },
+      ]),
+    ).toBe(true);
+  });
+
+  it("extracts production URL from Vercel comment", () => {
+    const url = extractProductionUrlFromComments([
+      {
+        author: "vercel[bot]",
+        body: "Deployed. [Production](https://example-target-app.vercel.app)",
+      },
+    ]);
+    expect(url).toBe("https://example-target-app.vercel.app");
+  });
+
+  it("extracts production URL from check details", () => {
+    const url = extractProductionUrlFromChecks([
+      {
+        name: "Vercel",
+        detailsUrl: "https://vercel.com/deployments/https://example-target-app.vercel.app",
+      },
+    ]);
+    expect(url).toContain("example-target-app.vercel.app");
+  });
+});

package/workspace-snapshot/files/tests/preview/vercel-from-pr.test.ts

@@ -0,0 +1,120 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it, vi } from "vitest";
+import {
+  extractVercelPreviewFromComments,
+  pollForVercelPreview,
+} from "../../src/preview/vercel-from-pr.js";
+
+const fixturesDir = path.join(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "../fixtures/github",
+);
+
+describe("extractVercelPreviewFromComments", () => {
+  it("extracts Preview link from PR #4 Vercel comment fixture", async () => {
+    const raw = await readFile(
+      path.join(fixturesDir, "pr-4-vercel-comment.json"),
+      "utf8",
+    );
+    const fixture = JSON.parse(raw) as {
+      comments: { author: string; body: string }[];
+      expectedPreviewUrl: string;
+    };
+
+    const result = extractVercelPreviewFromComments(fixture.comments);
+
+    expect(result.previewUrl).toBe(fixture.expectedPreviewUrl);
+    expect(result.source).toBe("vercel_comment");
+  });
+
+  it("falls back to scanning any comment for vercel.app URLs", () => {
+    const result = extractVercelPreviewFromComments([
+      {
+        author: "some-bot",
+        body: "Deploy at https://example-app-git-feature-team.vercel.app done",
+      },
+    ]);
+
+    expect(result.previewUrl).toBe(
+      "https://example-app-git-feature-team.vercel.app",
+    );
+    expect(result.source).toBe("vercel_url_scan");
+  });
+
+  it("returns null when no preview is found", () => {
+    const result = extractVercelPreviewFromComments([
+      { author: "user", body: "Looks good" },
+    ]);
+
+    expect(result.previewUrl).toBeNull();
+    expect(result.warnings.length).toBeGreaterThan(0);
+  });
+});
+
+describe("pollForVercelPreview", () => {
+  it("returns null with timeout warning when preview never appears", async () => {
+    const fetchComments = vi.fn().mockResolvedValue([
+      { author: "user", body: "No preview yet" },
+    ]);
+    const sleep = vi.fn().mockResolvedValue(undefined);
+
+    const result = await pollForVercelPreview(fetchComments, {
+      pollTimeoutSeconds: 0,
+      pollIntervalSeconds: 1,
+      sleep,
+    });
+
+    expect(result.previewUrl).toBeNull();
+    expect(result.warnings.some((w) => w.includes("Preview not found"))).toBe(
+      true,
+    );
+    expect(fetchComments.mock.calls.length).toBeGreaterThanOrEqual(0);
+  });
+
+  it("returns preview when it appears during polling", async () => {
+    const previewUrl =
+      "https://staging-git-cursor-example.vercel.app";
+    const fetchComments = vi
+      .fn()
+      .mockResolvedValueOnce([{ author: "user", body: "Waiting..." }])
+      .mockResolvedValueOnce([
+        {
+          author: "vercel[bot]",
+          body: `[Preview](${previewUrl})`,
+        },
+      ]);
+    const sleep = vi.fn().mockResolvedValue(undefined);
+
+    const result = await pollForVercelPreview(fetchComments, {
+      pollTimeoutSeconds: 5,
+      pollIntervalSeconds: 1,
+      sleep,
+    });
+
+    expect(result.previewUrl).toBe(previewUrl);
+    expect(sleep).toHaveBeenCalled();
+  });
+
+  it("does not hang when fetchComments never resolves", async () => {
+    vi.useFakeTimers();
+    const fetchComments = vi.fn().mockImplementation(
+      () => new Promise<{ author: string; body: string }[]>(() => undefined),
+    );
+
+    const resultPromise = pollForVercelPreview(fetchComments, {
+      pollTimeoutSeconds: 2,
+      pollIntervalSeconds: 1,
+    });
+
+    await vi.advanceTimersByTimeAsync(3_000);
+    const result = await resultPromise;
+
+    expect(result.previewUrl).toBeNull();
+    expect(
+      result.warnings.some((warning) => warning.includes("timed out")),
+    ).toBe(true);
+    vi.useRealTimers();
+  });
+});

package/workspace-snapshot/files/tests/prompts/builder.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "vitest";
+import { buildPlanningPrompt } from "../../src/prompts/builder.js";
+import type { LinearIssueSnapshot } from "../../src/linear/client.js";
+import type { ParsedIssue } from "../../src/types/parsed-issue.js";
+import type { ResolvedTarget } from "../../src/resolver/target-repo.js";
+
+const issue: LinearIssueSnapshot = {
+  id: "issue-1",
+  identifier: "WES-11",
+  title: "Hello world page",
+  description: "",
+  status: "Ready for Planning",
+  projectName: "Example Target App",
+  teamName: "WES",
+  teamId: "team-1",
+  url: null,
+};
+
+const parsed: ParsedIssue = {
+  task: "Add a hello world page",
+  acceptanceCriteria: ["Route renders Hello World"],
+  outOfScope: ["Harness changes"],
+  parseErrors: [],
+};
+
+const resolved: ResolvedTarget = {
+  targetRepo: "https://github.com/owner/example-target-app",
+  baseBranch: "main",
+  repoConfigId: "target-app",
+  resolutionSource: "explicit",
+  previewProvider: "vercel",
+};
+
+describe("buildPlanningPrompt", () => {
+  it("includes read-only planning constraints", async () => {
+    const { prompt, promptVersion } = await buildPlanningPrompt(
+      issue,
+      parsed,
+      resolved,
+    );
+
+    expect(promptVersion).toBe("planning@1");
+    expect(prompt).toContain("Do not** edit files");
+    expect(prompt).toContain("Do not** create a branch");
+    expect(prompt).toContain("Do not** open a PR");
+    expect(prompt).toContain("WES-11");
+    expect(prompt).toContain(resolved.targetRepo);
+    expect(prompt).toContain(parsed.task);
+  });
+
+  it("includes conditional release-impact requirements without authorizing release execution", async () => {
+    const { prompt } = await buildPlanningPrompt(issue, parsed, resolved);
+
+    expect(prompt).toContain("Release impact (conditional)");
+    expect(prompt).toContain("Do not** authorize publishing, tagging, deployment");
+    expect(prompt).toContain("human decision required");
+  });
+});

package/workspace-snapshot/files/tests/prompts/implementation-builder.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+import { buildBranchName } from "../../src/prompts/branch-name.js";
+import { buildImplementationPrompt } from "../../src/prompts/builder.js";
+import type { HarnessConfig } from "../../src/config/types.js";
+import type { LinearIssueSnapshot } from "../../src/linear/client.js";
+import type { ResolvedTarget } from "../../src/resolver/target-repo.js";
+import type { ParsedIssue } from "../../src/types/parsed-issue.js";
+
+const config: HarnessConfig = {
+  version: 1,
+  orchestratorMarker: "harness-orchestrator-v1",
+  logDirectory: "runs",
+  implementation: { branchPrefix: "cursor" },
+  repos: [],
+  allowedTargetRepos: ["https://github.com/owner/example-target-app"],
+};
+
+const issue: LinearIssueSnapshot = {
+  id: "issue-1",
+  identifier: "WES-12",
+  title: "M3 implementation integration test",
+  description: "",
+  status: "Ready for Build",
+  projectName: "Example Target App",
+  teamName: "WES",
+  teamId: "team-1",
+  url: "https://linear.app/example/issue/WES-12/test",
+};
+
+const parsed: ParsedIssue = {
+  task: "Add a temporary Hello World page",
+  acceptanceCriteria: ["A page exists", "A nav link exists"],
+  outOfScope: ["Merging the PR"],
+  validationExpectations: "Run npm run lint and npm run build.",
+  parseErrors: [],
+};
+
+const resolved: ResolvedTarget = {
+  targetRepo: "https://github.com/owner/example-target-app",
+  baseBranch: "main",
+  repoConfigId: "target-app",
+  resolutionSource: "explicit",
+  previewProvider: "vercel",
+};
+
+describe("implementation prompt builder", () => {
+  it("builds deterministic branch names", () => {
+    expect(buildBranchName(issue.identifier, issue.title, config)).toBe(
+      "cursor/wes-12-m3-implementation-integration-test",
+    );
+  });
+
+  it("includes implementation constraints and PR requirements", async () => {
+    const branchName = buildBranchName(issue.identifier, issue.title, config);
+    const { prompt, promptVersion } = await buildImplementationPrompt({
+      issue,
+      parsed,
+      resolved,
+      runId: "run-123",
+      branchName,
+      planningCommentBody: "## Implementation plan\n\nUse app routes.",
+      validationCommands: ["npm run lint", "npm run build"],
+    });
+
+    expect(promptVersion).toBe("implementation@1");
+    expect(prompt).toContain(branchName);
+    expect(prompt).toContain("Do not merge the PR");
+    expect(prompt).toContain("Do not create releases or tags");
+    expect(prompt).toContain("Do not publish npm packages or deploy");
+    expect(prompt).toContain("outstanding release preparation");
+    expect(prompt).toContain("## Implementation plan");
+    expect(prompt).toContain("npm run lint");
+    expect(prompt).toContain("[WES-12]");
+    expect(prompt).toContain("Harness run id: `run-123`");
+  });
+});

package/workspace-snapshot/files/tests/prompts/issue-intake-chatgpt.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it } from "vitest";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  checkProductionSyncIdempotency,
+} from "../../src/runner/idempotency.js";
+import type { HarnessConfig } from "../../src/config/types.js";
+import type { LinearIssueSnapshot } from "../../src/linear/client.js";
+
+const config: HarnessConfig = {
+  version: 1,
+  orchestratorMarker: "harness-orchestrator-v1",
+  logDirectory: "runs",
+  linear: {
+    transitionalStatuses: {
+      mergedToDev: "Merged to Dev",
+      mergedDeployed: "Merged / Deployed",
+    },
+  },
+  repos: [
+    {
+      id: "target-app",
+      linearProjects: ["Example Target App"],
+      targetRepo: "https://github.com/o/r",
+      baseBranch: "dev",
+      productionBranch: "main",
+      integrationSuccessStatus: "Merged to Dev",
+      productionSuccessStatus: "Merged / Deployed",
+    },
+  ],
+  allowedTargetRepos: ["https://github.com/o/r"],
+};
+
+const issue: LinearIssueSnapshot = {
+  id: "issue-1",
+  identifier: "WES-1",
+  title: "Test",
+  description: "",
+  status: "Merged to Dev",
+  projectName: "Example Target App",
+  teamName: null,
+  teamId: "team-1",
+  url: null,
+};
+
+describe("production sync idempotency", () => {
+  it("skips when issue is already Merged / Deployed", () => {
+    const result = checkProductionSyncIdempotency(
+      config,
+      { ...issue, status: "Merged / Deployed" },
+      [],
+      "abc123",
+      "Merged / Deployed",
+      "Merged to Dev",
+    );
+    expect(result.skip).toBe(true);
+  });
+
+  it("skips when production sync marker exists for merge commit", () => {
+    const result = checkProductionSyncIdempotency(
+      config,
+      issue,
+      [
+        {
+          id: "c1",
+          body: `---\nharness-orchestrator-v1\nphase: production_sync\nrun_id: sync-1\nmerge_commit_sha: abc123\n---`,
+        },
+      ],
+      "abc123",
+      "Merged / Deployed",
+      "Merged to Dev",
+    );
+    expect(result.skip).toBe(true);
+  });
+
+  it("allows sync when issue is Merged to Dev without marker", () => {
+    const result = checkProductionSyncIdempotency(
+      config,
+      issue,
+      [],
+      "abc123",
+      "Merged / Deployed",
+      "Merged to Dev",
+    );
+    expect(result.skip).toBe(false);
+  });
+});
+
+describe("intake prompt contract", () => {
+  it("uses simplified final package and required label guidance", async () => {
+    const promptPath = path.join(
+      path.dirname(fileURLToPath(import.meta.url)),
+      "../../prompts/issue-intake-chatgpt.md",
+    );
+    const prompt = await readFile(promptPath, "utf8");
+
+    expect(prompt).toContain("# Proposed Linear issue");
+    expect(prompt).toContain("**Recommended labels:**");
+    expect(prompt).toContain("**verify**");
+    expect(prompt).not.toContain("### Linear description (copy-paste)");
+    expect(prompt).not.toContain("## Linear issue package");
+    expect(prompt).not.toContain("Optional labels");
+  });
+});