p-dev-harness 0.3.1 → 0.4.0

package/workspace-snapshot/files/scripts/configure-step4-harness-readiness.spec.ts

@@ -0,0 +1,80 @@
+import { test, expect } from "@playwright/test";
+
+test.describe("configure step 4 harness readiness", () => {
+  test("enables create local setup files without false harness verify prompts", async ({
+    page,
+  }) => {
+    await page.route("**/api/setup/harness-provisioning-summary", async (route) => {
+      await route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({
+          runtimeMode: "source",
+          eligible: false,
+          state: "skipped-source-mode",
+          harnessDispatchRepo: "weston-uribe/agentic-product-development-harness",
+          authenticatedLogin: null,
+          message:
+            "Using harness workspace weston-uribe/agentic-product-development-harness from Step 1 setup.",
+          recoverable: false,
+          connectedAutomatically: false,
+          verifiedSavedRepo: true,
+        }),
+      });
+    });
+
+    await page.route("**/api/setup/verify-target-repo", async (route) => {
+      await route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({
+          status: "connected",
+          message:
+            "Connected to acme/example-target-app with repo + workflow install access.",
+          repoSlug: "acme/example-target-app",
+          workflowInstallReady: true,
+        }),
+      });
+    });
+
+    await page.goto("/settings/configure");
+
+    await expect(
+      page.getByText(/Step 4 of 7 · Choose target repo\(s\) and create setup files/),
+    ).toBeVisible({ timeout: 30_000 });
+
+    await expect(
+      page.getByText(
+        "Verify and use this harness repo before creating local setup files.",
+      ),
+    ).toHaveCount(0);
+    await expect(
+      page.getByText(
+        "Verify and use your harness repo before creating local setup files.",
+      ),
+    ).toHaveCount(0);
+
+    await page
+      .getByPlaceholder("https://github.com/acme/my-product")
+      .fill("https://github.com/acme/example-target-app");
+
+    const verifyRepoButton = page.getByRole("button", {
+      name: "Verify repo + workflow access",
+    });
+    if (await verifyRepoButton.isEnabled()) {
+      await verifyRepoButton.click();
+    }
+
+    await expect(page.getByRole("button", { name: "Verified" })).toBeVisible();
+
+    await page
+      .getByRole("checkbox", {
+        name: "I understand this will create local setup files on this machine.",
+      })
+      .check();
+
+    await expect(
+      page.getByRole("button", { name: "Create local setup files" }),
+    ).toBeEnabled();
+  });
+});

package/workspace-snapshot/files/scripts/prepare-configure-browser-workspace.ts

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import { execFile } from "node:child_process";
+import { access, mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+async function ensureGitRepo(dir: string): Promise<void> {
+  const gitDir = path.join(dir, ".git");
+  try {
+    await access(gitDir);
+  } catch {
+    await execFileAsync("git", ["init"], { cwd: dir });
+    await execFileAsync("git", ["config", "user.email", "configure-browser@test.local"], {
+      cwd: dir,
+    });
+    await execFileAsync("git", ["config", "user.name", "Configure Browser Test"], {
+      cwd: dir,
+    });
+  }
+
+  try {
+    await execFileAsync(
+      "git",
+      [
+        "remote",
+        "add",
+        "origin",
+        "https://github.com/weston-uribe/agentic-product-development-harness.git",
+      ],
+      { cwd: dir },
+    );
+  } catch {
+    await execFileAsync(
+      "git",
+      [
+        "remote",
+        "set-url",
+        "origin",
+        "https://github.com/weston-uribe/agentic-product-development-harness.git",
+      ],
+      { cwd: dir },
+    );
+  }
+}
+
+async function main(): Promise<void> {
+  const configured = process.env.CONFIGURE_BROWSER_WORKSPACE?.trim();
+  const workspaceDir =
+    configured ||
+    path.join(tmpdir(), `configure-browser-${process.pid}-${Date.now()}`);
+
+  await mkdir(path.join(workspaceDir, ".harness"), { recursive: true });
+  await ensureGitRepo(workspaceDir);
+
+  await writeFile(
+    path.join(workspaceDir, ".env.local"),
+    [
+      "LINEAR_API_KEY=linear-browser-test-token",
+      "CURSOR_API_KEY=cursor-browser-test-token",
+      "GITHUB_TOKEN=github-browser-test-token",
+      "VERCEL_TOKEN=vercel-browser-test-token",
+      "HARNESS_CONFIG_PATH=.harness/config.local.json",
+      "",
+    ].join("\n"),
+    "utf8",
+  );
+
+  await writeFile(
+    path.join(workspaceDir, ".harness/config.local.json"),
+    `${JSON.stringify(
+      {
+        repos: [
+          {
+            id: "target-app",
+            targetRepo: "https://github.com/owner/example-target-app",
+            baseBranch: "dev",
+            productionBranch: "main",
+          },
+        ],
+        linearTeamKey: "ENG",
+      },
+      null,
+      2,
+    )}\n`,
+    "utf8",
+  );
+
+  await writeFile(
+    path.join(workspaceDir, ".harness/control-plane-setup.json"),
+    `${JSON.stringify(
+      {
+        version: 1,
+        linear: {
+          teamMode: "existing",
+          teamId: "team-1",
+          teamKey: "ENG",
+          teamName: "Engineering",
+          projectMode: "existing",
+          projectId: "proj-1",
+          projectName: "Harness",
+          statusCoverageComplete: true,
+          appliedAt: "2026-07-16T00:00:00.000Z",
+        },
+      },
+      null,
+      2,
+    )}\n`,
+    "utf8",
+  );
+
+  const skipDisclosure = process.env.CONFIGURE_BROWSER_SKIP_DISCLOSURE === "1";
+  if (!skipDisclosure) {
+    await writeFile(
+      path.join(workspaceDir, ".harness/observability.local.json"),
+      `${JSON.stringify(
+        {
+          analyticsPreference: "disabled",
+          errorReportingPreference: "disabled",
+          disclosureShown: true,
+        },
+        null,
+        2,
+      )}\n`,
+      "utf8",
+    );
+  }
+
+  process.stdout.write(`${workspaceDir}\n`);
+}
+
+main().catch((error: unknown) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`prepare-configure-browser-workspace failed: ${message}`);
+  process.exit(1);
+});

package/workspace-snapshot/files/scripts/prepare-p-dev-package.ts

@@ -5,6 +5,7 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { generateWorkspaceSnapshot } from "../src/p-dev/workspace-snapshot-generator.js";
 import { assertCleanGitSource } from "../src/p-dev/workspace-snapshot-git.js";
+import { resolveObservabilityPublicConfigForPrepare } from "../src/observability/package-config.js";
 
 const execFileAsync = promisify(execFile);
 
@@ -123,6 +124,14 @@ import "../dist/p-dev/main.js";
     path.join(packageDir, "LICENSE"),
   );
 
+  console.log("Copying tracked public observability configuration…");
+  const observabilityConfig = resolveObservabilityPublicConfigForPrepare(repoRoot);
+  await writeFile(
+    path.join(packageDir, "observability.public.json"),
+    `${JSON.stringify(observabilityConfig, null, 2)}\n`,
+    "utf8",
+  );
+
   const packageJson = JSON.parse(
     await readFile(path.join(packageDir, "package.json"), "utf8"),
   ) as { version: string };

package/workspace-snapshot/files/scripts/workflow-browser-matrix.config.ts

@@ -0,0 +1,27 @@
+// Prerequisite: npx playwright install chromium
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "@playwright/test";
+
+const repoRoot = path.join(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+export default defineConfig({
+  testDir: path.join(repoRoot, "scripts"),
+  testMatch: "workflow-browser-matrix.spec.ts",
+  timeout: 120_000,
+  workers: 1,
+  use: {
+    baseURL: "http://localhost:3100",
+    screenshot: "only-on-failure",
+    trace: "off",
+  },
+  webServer: {
+    command:
+      "P_DEV_OBSERVABILITY_DISABLED=1 P_DEV_OPERATIONS_FIXTURES=1 npx tsx src/gui/start-gui.ts --port 3100",
+    cwd: repoRoot,
+    url: "http://localhost:3100/workflow?source=fixture&fixture=branching-pr-review&scope=harness-repo",
+    reuseExistingServer: false,
+    timeout: 180_000,
+  },
+  outputDir: "/tmp/workflow-validation/playwright-results",
+});

package/workspace-snapshot/files/scripts/workflow-browser-matrix.spec.ts

@@ -0,0 +1,151 @@
+import { mkdirSync } from "node:fs";
+import { test, expect, type Page } from "@playwright/test";
+
+const screenshotDir = "/tmp/workflow-validation";
+const FIXTURE_URL =
+  "/workflow?source=fixture&fixture=branching-pr-review&scope=harness-repo";
+
+async function expandStatus(page: Page, statusName: string): Promise<void> {
+  const button = page.getByRole("button", { name: new RegExp(`^${statusName}\\s`) });
+  if ((await button.getAttribute("aria-expanded")) === "false") {
+    await button.click();
+  }
+}
+
+async function assertNoDocumentOverflow(page: Page): Promise<void> {
+  const overflow = await page.evaluate(
+    () =>
+      document.documentElement.scrollWidth > window.innerWidth + 2 ||
+      document.documentElement.scrollHeight > window.innerHeight + 2,
+  );
+  expect(overflow).toBe(false);
+}
+
+async function setTheme(page: Page, theme: "light" | "dark"): Promise<void> {
+  await page.evaluate((nextTheme) => {
+    document.documentElement.classList.remove("light", "dark");
+    document.documentElement.classList.add(nextTheme);
+    document.documentElement.style.colorScheme = nextTheme;
+  }, theme);
+}
+
+test.describe("workflow browser matrix", () => {
+  test.beforeAll(() => {
+    mkdirSync(screenshotDir, { recursive: true });
+  });
+
+  test("workflow page renders cards-only UI on first load", async ({ page }) => {
+    const consoleErrors: string[] = [];
+    page.on("console", (message) => {
+      if (message.type() === "error") {
+        consoleErrors.push(message.text());
+      }
+    });
+
+    await page.goto(FIXTURE_URL);
+    await expect(page.getByRole("heading", { name: "Workflow", level: 1 })).toBeVisible();
+    await expect(page.getByRole("region", { name: "Workflow health" })).toBeVisible();
+    await expect(page.getByRole("region", { name: "Human-owned" })).toBeVisible();
+    await expect(page.getByRole("region", { name: "Harness-owned" })).toBeVisible();
+    await expect(page.getByRole("region", { name: "Agent-owned" })).toBeVisible();
+    await expect(page.getByText("Draft — Changes are not active.")).toHaveCount(0);
+    await expect(page.getByText("Inspector")).toHaveCount(0);
+    await expect(page.getByRole("button", { name: "Add", exact: true })).toHaveCount(0);
+    await expect(page.getByText("Engineering Review").first()).toBeVisible();
+    await page.screenshot({ path: `${screenshotDir}/workflow-desktop.png`, fullPage: true });
+    expect(consoleErrors).toEqual([]);
+  });
+
+  test("workflow cards expose model controls and autosave", async ({ page }) => {
+    await page.setViewportSize({ width: 1440, height: 900 });
+    await page.goto(FIXTURE_URL);
+
+    await expandStatus(page, "Planning");
+    await expect(page.getByText("Planner model")).toBeVisible();
+
+    const saveResponse = page.waitForResponse(
+      (response) =>
+        response.url().includes("/api/workflow/models") &&
+        response.request().method() === "PUT",
+    );
+    await page.getByRole("switch", { name: "Fast mode" }).click();
+    const response = await saveResponse;
+    expect(response.ok()).toBe(true);
+    await expect(page.getByText("Saved").first()).toBeVisible({ timeout: 20_000 });
+
+    await assertNoDocumentOverflow(page);
+  });
+
+  test("fast mode switch triggers production autosave", async ({ page }) => {
+    await page.goto(FIXTURE_URL);
+    await expandStatus(page, "Planning");
+
+    const fastSwitch = page.getByRole("switch", { name: "Fast mode" });
+    await fastSwitch.click();
+    await expect(page.getByText("Saved").first()).toBeVisible({ timeout: 20_000 });
+    await expect(page.getByText("Couldn't save")).toHaveCount(0);
+  });
+
+  test("branching merge path fixture is healthy", async ({ page }) => {
+    await page.goto(FIXTURE_URL);
+    await expect(page.getByText("Workflow health: Healthy")).toBeVisible();
+    await expect(page.getByText("Needs attention")).toHaveCount(0);
+  });
+
+  test("missing canonical status surfaces workflow health attention", async ({ page }) => {
+    await page.goto(
+      "/workflow?source=fixture&fixture=empty-linear-statuses&scope=harness-repo",
+    );
+    await expect(page.getByText("Workflow health: Needs attention")).toBeVisible();
+    await expect(page.getByLabel("Needs attention").first()).toBeVisible();
+  });
+
+  test("/operations redirects to workflow", async ({ page }) => {
+    await page.goto(
+      "/operations?source=fixture&fixture=branching-pr-review&scope=harness-repo",
+    );
+    await expect(page).toHaveURL(/\/workflow/);
+    await expect(page.getByRole("heading", { name: "Workflow", level: 1 })).toBeVisible();
+  });
+
+  test("light and dark themes render workflow health", async ({ page }) => {
+    await page.goto(FIXTURE_URL);
+    await setTheme(page, "light");
+    await expect(page.getByRole("region", { name: "Workflow health" })).toBeVisible();
+    await page.screenshot({ path: `${screenshotDir}/workflow-light-mode.png`, fullPage: true });
+
+    await setTheme(page, "dark");
+    await expect(page.getByRole("region", { name: "Workflow health" })).toBeVisible();
+    await page.screenshot({ path: `${screenshotDir}/workflow-dark-mode.png`, fullPage: true });
+  });
+
+  test("fixture scopes isolate model selections between repositories", async ({ page }) => {
+    await page.goto("/workflow?source=fixture&fixture=branching-pr-review&scope=target-app");
+    await expandStatus(page, "Planning");
+    await page.getByRole("switch", { name: "Fast mode" }).click();
+    await expect(page.getByText("Saved").first()).toBeVisible({ timeout: 20_000 });
+
+    await page.selectOption("#workflow-scope-select", "harness-repo");
+    await page.waitForResponse((response) =>
+      response.url().includes("/api/workflow/bootstrap"),
+    );
+    await expandStatus(page, "Planning");
+    await expect(page.getByRole("switch", { name: "Fast mode" })).not.toBeChecked();
+  });
+
+  test("mobile viewport renders primary workflow content", async ({ page }) => {
+    await page.setViewportSize({ width: 390, height: 844 });
+    await page.goto(FIXTURE_URL);
+    await expect(page.getByRole("heading", { name: "Workflow", level: 1 })).toBeVisible();
+    await expect(page.getByRole("region", { name: "Workflow health" })).toBeVisible();
+  });
+
+  test("settings menu exposes data sharing from workflow", async ({ page }) => {
+    await page.goto(FIXTURE_URL);
+    await page.getByRole("button", { name: "Settings", exact: true }).click();
+    await page.getByRole("menuitem", { name: "Data sharing" }).click();
+    await expect(page).toHaveURL(/\/settings\/data-sharing$/);
+    await expect(page.getByText(/^Data sharing$/)).toBeVisible();
+    await expect(page.getByRole("button", { name: "Save changes" })).toBeVisible();
+  });
+});

package/workspace-snapshot/files/src/agents/cursor-provider.ts

@@ -1,20 +1,19 @@
 import {
   createImplementationCloudAgent,
-  createIntegrationRepairCloudAgent,
   createPlanningCloudAgent,
-  createRevisionCloudAgent,
   disposeCloudAgent,
 } from "../cursor/agent-factory.js";
 import { resolveModelId as cursorResolveModelId } from "../cursor/model.js";
 import { sendAndObserve as cursorSendAndObserve } from "../cursor/run-observer.js";
+import { acquireBuilderAgent as acquireBuilderAgentImpl } from "../runner/builder-thread-acquire.js";
 import type {
+  AcquiredBuilderAgent,
+  AcquireBuilderAgentParams,
   AgentHandle,
   AgentProvider,
   ImplementationAgentParams,
-  IntegrationRepairAgentParams,
   ObservedAgentRun,
   PlanningAgentParams,
-  RevisionAgentParams,
   SendAndObserveOptions,
 } from "./types.js";
 import type { HarnessConfig } from "../config/types.js";
@@ -44,6 +43,7 @@ function mapObservedRun(
   return {
     agentId: observed.agentId,
     runId: observed.runId,
+    requestId: observed.requestId,
     assistantText: observed.assistantText,
     gitResult: observed.gitResult,
     cancelOutcome: observed.cancelOutcome,
@@ -69,16 +69,14 @@ export const cursorAgentProvider: AgentProvider = {
     return wrapCursorAgent(agent);
   },
 
-  async createRevisionAgent(params: RevisionAgentParams): Promise<AgentHandle> {
-    const agent = await createRevisionCloudAgent(params);
-    return wrapCursorAgent(agent);
-  },
-
-  async createIntegrationRepairAgent(
-    params: IntegrationRepairAgentParams,
-  ): Promise<AgentHandle> {
-    const agent = await createIntegrationRepairCloudAgent(params);
-    return wrapCursorAgent(agent);
+  async acquireBuilderAgent(
+    params: AcquireBuilderAgentParams,
+  ): Promise<AcquiredBuilderAgent> {
+    const acquired = await acquireBuilderAgentImpl(params);
+    return {
+      agent: wrapCursorAgent(acquired.agent),
+      continuity: acquired.continuity,
+    };
   },
 
   async sendAndObserve(

package/workspace-snapshot/files/src/agents/index.ts

@@ -1,11 +1,11 @@
 import { cursorAgentProvider } from "./cursor-provider.js";
 import { getAgentProvider } from "./provider.js";
 import type {
+  AcquireBuilderAgentParams,
+  AcquiredBuilderAgent,
   AgentHandle,
   ImplementationAgentParams,
-  IntegrationRepairAgentParams,
   PlanningAgentParams,
-  RevisionAgentParams,
   SendAndObserveOptions,
 } from "./types.js";
 import type { HarnessConfig } from "../config/types.js";
@@ -27,16 +27,10 @@ export function createImplementationAgent(
   return getAgentProvider(params.config).createImplementationAgent(params);
 }
 
-export function createRevisionAgent(
-  params: RevisionAgentParams,
-): Promise<AgentHandle> {
-  return getAgentProvider(params.config).createRevisionAgent(params);
-}
-
-export function createIntegrationRepairAgent(
-  params: IntegrationRepairAgentParams,
-): Promise<AgentHandle> {
-  return getAgentProvider(params.config).createIntegrationRepairAgent(params);
+export function acquireBuilderAgent(
+  params: AcquireBuilderAgentParams,
+): Promise<AcquiredBuilderAgent> {
+  return getAgentProvider(params.config).acquireBuilderAgent(params);
 }
 
 export function sendAndObserve(
@@ -60,6 +54,8 @@ export function disposeAgent(agent: AgentHandle): Promise<void> {
 }
 
 export type {
+  AcquireBuilderAgentParams,
+  AcquiredBuilderAgent,
   AgentHandle,
   CapturedGitResult,
   CursorCancelOutcome,

package/workspace-snapshot/files/src/agents/types.ts

@@ -1,5 +1,10 @@
 import type { HarnessConfig } from "../config/types.js";
 import type { EventLogger } from "../artifacts/events.js";
+import type { LinearCommentRecord } from "../linear/writer.js";
+import type {
+  BuilderThreadResolution,
+  BuilderThreadSourcePhase,
+} from "../runner/builder-thread-types.js";
 
 export type AgentObservePhase =
   | "planning"
@@ -21,6 +26,7 @@ export interface CapturedGitResult {
 export interface ObservedAgentRun {
   agentId: string;
   runId: string;
+  requestId?: string;
   assistantText: string;
   gitResult: CapturedGitResult | null;
   cancelOutcome: CursorCancelOutcome | null;
@@ -50,6 +56,10 @@ export interface BranchAgentParams {
 export type RevisionAgentParams = BranchAgentParams;
 export type IntegrationRepairAgentParams = BranchAgentParams;
 
+export interface AgentModelSelection {
+  id: string;
+}
+
 export interface SendAndObserveOptions {
   phase?: AgentObservePhase;
   targetRepo?: string;
@@ -58,7 +68,36 @@ export interface SendAndObserveOptions {
   abortSignal?: AbortSignal;
   apiKey?: string;
   pollIntervalMs?: number;
+  model?: AgentModelSelection;
+  mode?: "agent" | "plan";
+  idempotencyKey?: string;
   onAgentCreated?: (details: { agentId: string; runId: string }) => Promise<void>;
+  onBeforeSend?: (details: { agentId: string }) => Promise<void>;
+}
+
+export interface AcquireBuilderAgentParams {
+  apiKey: string;
+  config: HarnessConfig;
+  phase: BuilderThreadSourcePhase;
+  context: {
+    issueKey: string;
+    harnessRunId: string;
+    targetRepo: string;
+    baseBranch: string;
+    branch?: string;
+    prUrl?: string;
+    idempotencyKey: string;
+    comments: LinearCommentRecord[];
+    orchestratorMarker: string;
+    previousImplementationRunId?: string;
+    previousRevisionRunId?: string;
+  };
+  events: EventLogger;
+}
+
+export interface AcquiredBuilderAgent {
+  agent: AgentHandle;
+  continuity: BuilderThreadResolution;
 }
 
 export interface AgentProvider {
@@ -68,10 +107,7 @@ export interface AgentProvider {
 
   createPlanningAgent(params: PlanningAgentParams): Promise<AgentHandle>;
   createImplementationAgent(params: ImplementationAgentParams): Promise<AgentHandle>;
-  createRevisionAgent(params: RevisionAgentParams): Promise<AgentHandle>;
-  createIntegrationRepairAgent(
-    params: IntegrationRepairAgentParams,
-  ): Promise<AgentHandle>;
+  acquireBuilderAgent(params: AcquireBuilderAgentParams): Promise<AcquiredBuilderAgent>;
 
   sendAndObserve(
     agent: AgentHandle,

package/workspace-snapshot/files/src/artifacts/redact.ts

@@ -1,12 +1,28 @@
-const SECRET_PATTERNS = [
+export const CREDENTIAL_SECRET_PATTERNS = [
   /lin_api_[A-Za-z0-9_]+/gi,
   /ghp_[A-Za-z0-9]+/gi,
+  /gho_[A-Za-z0-9]+/gi,
+  /ghu_[A-Za-z0-9]+/gi,
+  /ghs_[A-Za-z0-9]+/gi,
+  /ghr_[A-Za-z0-9]+/gi,
   /github_pat_[A-Za-z0-9_]+/gi,
   /cursor_[A-Za-z0-9_]+/gi,
   /sk-[A-Za-z0-9_-]+/gi,
   /xox[baprs]-[A-Za-z0-9-]+/gi,
   /Bearer\s+[A-Za-z0-9._-]+/gi,
-];
+] as const;
+
+const SECRET_PATTERNS = CREDENTIAL_SECRET_PATTERNS;
+
+export function stringContainsCredentialSecret(value: string): boolean {
+  for (const pattern of CREDENTIAL_SECRET_PATTERNS) {
+    pattern.lastIndex = 0;
+    if (pattern.test(value)) {
+      return true;
+    }
+  }
+  return false;
+}
 
 const MAX_REDACTED_ERROR_LENGTH = 200;