p-dev-harness 0.3.1 → 0.4.0

package/workspace-snapshot/files/src/workflow-page/fixture-role-models.ts

@@ -0,0 +1,50 @@
+import type { HarnessConfig } from "../config/types.js";
+import type { RoleModelRole } from "../config/role-models.js";
+import { buildConfigFingerprint } from "./bootstrap.js";
+
+const fixtureRoleModels = new Map<string, HarnessConfig["roleModels"]>();
+
+function storageKey(fixtureId: string, scopeId: string): string {
+  return `${fixtureId}::${scopeId}`;
+}
+
+export function getFixtureRoleModels(
+  fixtureId: string,
+  scopeId: string,
+): HarnessConfig["roleModels"] | null {
+  return fixtureRoleModels.get(storageKey(fixtureId, scopeId)) ?? null;
+}
+
+export function saveFixtureRoleModel(input: {
+  fixtureId: string;
+  scopeId: string;
+  baseConfig: HarnessConfig;
+  role: RoleModelRole;
+  modelId: string;
+  params: Array<{ id: string; value: string }>;
+}): { configFingerprint: string; roleModels: HarnessConfig["roleModels"] } {
+  const key = storageKey(input.fixtureId, input.scopeId);
+  const current = fixtureRoleModels.get(key) ?? input.baseConfig.roleModels ?? {};
+  const selection = input.params.length
+    ? { id: input.modelId, params: input.params }
+    : { id: input.modelId };
+  const next = {
+    ...current,
+    [input.role]: selection,
+  };
+  fixtureRoleModels.set(key, next);
+
+  const mergedConfig: HarnessConfig = {
+    ...input.baseConfig,
+    roleModels: next,
+  };
+
+  return {
+    configFingerprint: buildConfigFingerprint(mergedConfig),
+    roleModels: next,
+  };
+}
+
+export function resetFixtureRoleModelsForTests(): void {
+  fixtureRoleModels.clear();
+}

package/workspace-snapshot/files/src/workflow-page/fixtures/basic-current-workflow.ts

@@ -0,0 +1,39 @@
+import type { WorkflowFixtureDefinition } from "../fixture-definition.js";
+import { getFixtureModelCatalog } from "./model-catalog-snapshot.js";
+import { getFixtureWorkflowScopes } from "./workflow-scopes.js";
+
+const WORKFLOW_STATUSES = [
+  ["status-backlog", "Backlog", "backlog"],
+  ["status-ready-planning", "Ready for Planning", "unstarted"],
+  ["status-planning", "Planning", "started"],
+  ["status-ready-build", "Ready for Build", "unstarted"],
+  ["status-building", "Building", "started"],
+  ["status-pr-open", "PR Open", "started"],
+  ["status-pm-review", "PM Review", "started"],
+  ["status-eng-review", "Engineering Review", "started"],
+  ["status-needs-revision", "Needs Revision", "unstarted"],
+  ["status-revising", "Revising", "started"],
+  ["status-ready-merge", "Ready to Merge", "started"],
+  ["status-merging", "Merging", "started"],
+  ["status-merged-dev", "Merged to Dev", "completed"],
+  ["status-merged-deployed", "Merged / Deployed", "completed"],
+  ["status-blocked", "Blocked", "started"],
+  ["status-canceled", "Canceled", "canceled"],
+  ["status-duplicate", "Duplicate", "duplicate"],
+] as const;
+
+export const basicCurrentWorkflowFixture: WorkflowFixtureDefinition = {
+  id: "basic-current-workflow",
+  workflowScopes: getFixtureWorkflowScopes(),
+  statuses: WORKFLOW_STATUSES.map(([id, name, type]) => ({
+    id,
+    name,
+    type,
+  })),
+  modelCatalog: getFixtureModelCatalog(),
+  warnings: [
+    "Internal in-progress statuses remain available in the catalog but are not primary canvas nodes.",
+  ],
+};
+
+export { WORKFLOW_STATUSES };

package/workspace-snapshot/files/src/workflow-page/fixtures/branching-pr-review.ts

@@ -0,0 +1,11 @@
+import type { WorkflowFixtureDefinition } from "../fixture-definition.js";
+import { basicCurrentWorkflowFixture } from "./basic-current-workflow.js";
+
+export const branchingPrReviewFixture: WorkflowFixtureDefinition = {
+  ...basicCurrentWorkflowFixture,
+  id: "branching-pr-review",
+  warnings: [
+    "Fixture includes a planned PR Review Agent with branching outcomes.",
+    ...basicCurrentWorkflowFixture.warnings,
+  ],
+};

package/workspace-snapshot/files/src/workflow-page/fixtures/canonical-violations.ts

@@ -0,0 +1,50 @@
+import type { WorkflowFixtureDefinition } from "../fixture-definition.js";
+import { basicCurrentWorkflowFixture } from "./basic-current-workflow.js";
+
+function withStatuses(
+  id: WorkflowFixtureDefinition["id"],
+  statuses: WorkflowFixtureDefinition["statuses"],
+  warnings: string[],
+): WorkflowFixtureDefinition {
+  return {
+    ...basicCurrentWorkflowFixture,
+    id,
+    statuses,
+    warnings: [...warnings, ...basicCurrentWorkflowFixture.warnings],
+  };
+}
+
+export const canonicalCaseRenameFixture = withStatuses(
+  "canonical-case-rename",
+  basicCurrentWorkflowFixture.statuses.map((status) =>
+    status.name === "Ready for Build"
+      ? { ...status, name: "ready for build" }
+      : status,
+  ),
+  ["Fixture simulates a case-only rename of Ready for Build."],
+);
+
+export const canonicalWrongCategoryFixture = withStatuses(
+  "canonical-wrong-category",
+  basicCurrentWorkflowFixture.statuses.map((status) =>
+    status.name === "Ready for Build" ? { ...status, type: "started" } : status,
+  ),
+  ["Fixture simulates Ready for Build in the wrong Linear category."],
+);
+
+export const canonicalWhitespaceNameFixture = withStatuses(
+  "canonical-whitespace-name",
+  basicCurrentWorkflowFixture.statuses.map((status) =>
+    status.name === "Ready for Build" ? { ...status, name: " Ready for Build" } : status,
+  ),
+  ["Fixture simulates a leading-space deviation on Ready for Build."],
+);
+
+export const canonicalPlanReviewPresentFixture = withStatuses(
+  "canonical-plan-review-present",
+  [
+    ...basicCurrentWorkflowFixture.statuses,
+    { id: "status-plan-review", name: "Plan Review", type: "started" },
+  ],
+  ["Fixture includes deprecated Plan Review as an extra Linear status."],
+);

package/workspace-snapshot/files/src/workflow-page/fixtures/credential-errors.ts

@@ -0,0 +1,13 @@
+import type { WorkflowFixtureDefinition } from "../fixture-definition.js";
+import { buildCatalogUnavailableEntry } from "../model-catalog-utils.js";
+import { getFixtureWorkflowScopes } from "./workflow-scopes.js";
+
+export const credentialErrorsFixture: WorkflowFixtureDefinition = {
+  id: "credential-errors",
+  workflowScopes: getFixtureWorkflowScopes(),
+  statuses: [],
+  modelCatalog: buildCatalogUnavailableEntry("fixture"),
+  warnings: [
+    "Fixture simulates missing or failed Linear/Cursor credential reads.",
+  ],
+};

package/workspace-snapshot/files/src/workflow-page/fixtures/empty-linear-statuses.ts

@@ -0,0 +1,10 @@
+import type { WorkflowFixtureDefinition } from "../fixture-definition.js";
+import { getFixtureWorkflowScopes } from "./workflow-scopes.js";
+
+export const emptyLinearStatusesFixture: WorkflowFixtureDefinition = {
+  id: "empty-linear-statuses",
+  workflowScopes: getFixtureWorkflowScopes(),
+  statuses: [],
+  modelCatalog: [],
+  warnings: ["Fixture simulates an empty Linear status catalog."],
+};

package/workspace-snapshot/files/src/workflow-page/fixtures/hundred-node-performance.ts

@@ -0,0 +1,23 @@
+import type { WorkflowFixtureDefinition } from "../fixture-definition.js";
+import { getFixtureModelCatalog } from "./model-catalog-snapshot.js";
+import { getFixtureWorkflowScopes } from "./workflow-scopes.js";
+
+function buildPerformanceStatuses() {
+  const statuses = [];
+  for (let index = 1; index <= 100; index += 1) {
+    statuses.push({
+      id: `perf-status-${index}`,
+      name: `Performance Status ${index}`,
+      type: index % 5 === 0 ? "completed" : index % 3 === 0 ? "started" : "unstarted",
+    });
+  }
+  return statuses;
+}
+
+export const hundredNodePerformanceFixture: WorkflowFixtureDefinition = {
+  id: "hundred-node-performance",
+  workflowScopes: getFixtureWorkflowScopes(),
+  statuses: buildPerformanceStatuses(),
+  modelCatalog: getFixtureModelCatalog(),
+  warnings: ["Fixture includes 100 statuses for canvas performance testing."],
+};

package/workspace-snapshot/files/src/workflow-page/fixtures/index.ts

@@ -0,0 +1,37 @@
+import type { WorkflowFixtureId } from "../constants.js";
+import { basicCurrentWorkflowFixture } from "./basic-current-workflow.js";
+import { branchingPrReviewFixture } from "./branching-pr-review.js";
+import { emptyLinearStatusesFixture } from "./empty-linear-statuses.js";
+import { credentialErrorsFixture } from "./credential-errors.js";
+import { hundredNodePerformanceFixture } from "./hundred-node-performance.js";
+import {
+  canonicalCaseRenameFixture,
+  canonicalPlanReviewPresentFixture,
+  canonicalWhitespaceNameFixture,
+  canonicalWrongCategoryFixture,
+} from "./canonical-violations.js";
+import type { WorkflowFixtureDefinition } from "../fixture-definition.js";
+
+const FIXTURES: Record<WorkflowFixtureId, WorkflowFixtureDefinition> = {
+  "basic-current-workflow": basicCurrentWorkflowFixture,
+  "branching-pr-review": branchingPrReviewFixture,
+  "empty-linear-statuses": emptyLinearStatusesFixture,
+  "credential-errors": credentialErrorsFixture,
+  "hundred-node-performance": hundredNodePerformanceFixture,
+  "canonical-case-rename": canonicalCaseRenameFixture,
+  "canonical-wrong-category": canonicalWrongCategoryFixture,
+  "canonical-whitespace-name": canonicalWhitespaceNameFixture,
+  "canonical-plan-review-present": canonicalPlanReviewPresentFixture,
+};
+
+export function getFixtureDefinition(
+  fixtureId: WorkflowFixtureId,
+): WorkflowFixtureDefinition {
+  return FIXTURES[fixtureId];
+}
+
+export function listFixtureDefinitions(): WorkflowFixtureDefinition[] {
+  return Object.values(FIXTURES);
+}
+
+export type { WorkflowFixtureDefinition } from "../fixture-definition.js";

package/workspace-snapshot/files/src/workflow-page/fixtures/model-catalog-snapshot.ts

@@ -0,0 +1,34 @@
+import type { WorkflowModelCatalogEntry } from "../types.js";
+
+/**
+ * Verified Cursor.models.list() capture was not available in this implementation
+ * environment (no CURSOR_API_KEY). Fixture mode uses this deterministic snapshot
+ * with the models confirmed in prior fixture seeds only.
+ */
+export const FIXTURE_MODEL_CATALOG_CAPTURED_AT = "2026-01-01T00:00:00.000Z";
+
+export const FIXTURE_MODEL_CATALOG_LIMITATION =
+  "Multi-model fixture catalog requires a verified Cursor.models.list() capture. Only models from existing fixture seeds are included until capture is available.";
+
+export function getFixtureModelCatalog(): WorkflowModelCatalogEntry[] {
+  return FIXTURE_MODEL_CATALOG.map((entry) => ({ ...entry }));
+}
+
+const FIXTURE_MODEL_CATALOG: WorkflowModelCatalogEntry[] = [
+  {
+    id: "composer-2.5",
+    displayName: "Composer 2.5",
+    availability: "available",
+    supportedParameters: [
+      {
+        id: "fast",
+        label: "Fast mode",
+        type: "boolean",
+        allowedValues: ["true", "false"],
+        defaultValue: "true",
+      },
+    ],
+    fetchedAt: FIXTURE_MODEL_CATALOG_CAPTURED_AT,
+    source: "fixture",
+  },
+];

package/workspace-snapshot/files/src/workflow-page/fixtures/workflow-scopes.ts

@@ -0,0 +1,18 @@
+import type { WorkflowScope } from "../types.js";
+
+export const FIXTURE_WORKFLOW_SCOPES: WorkflowScope[] = [
+  {
+    id: "target-app",
+    targetRepo: "weston-uribe/example-target-app",
+    linearTeams: ["Product Development"],
+  },
+  {
+    id: "harness-repo",
+    targetRepo: "weston-uribe/agentic-product-development-harness",
+    linearTeams: ["Harness"],
+  },
+];
+
+export function getFixtureWorkflowScopes(): WorkflowScope[] {
+  return FIXTURE_WORKFLOW_SCOPES.map((scope) => ({ ...scope }));
+}

package/workspace-snapshot/files/src/workflow-page/linear-status-source.ts

@@ -0,0 +1,65 @@
+import {
+  createLinearSetupClient,
+  listTeamWorkflowStates,
+} from "../setup/linear-setup-client.js";
+import type { LinearStatusInput } from "./current-workflow.js";
+import type { CatalogLoadState } from "./types.js";
+import { hashWorkflowFingerprint } from "./fingerprint.js";
+
+export interface LinearStatusLoadResult {
+  statuses: LinearStatusInput[];
+  loadState: CatalogLoadState;
+  warning?: string;
+  error?: string;
+}
+
+export async function loadLiveLinearStatuses(input: {
+  apiKey: string;
+  teamId: string;
+}): Promise<LinearStatusLoadResult> {
+  try {
+    const client = createLinearSetupClient(input.apiKey);
+    const states = await listTeamWorkflowStates(client, input.teamId);
+    return {
+      statuses: states.map((state) => ({
+        id: state.id,
+        name: state.name,
+        type: state.type,
+      })),
+      loadState: "loaded",
+    };
+  } catch (error) {
+    const message =
+      error instanceof Error ? error.message : "Linear status load failed.";
+    return {
+      statuses: [],
+      loadState: "unavailable",
+      error: message,
+    };
+  }
+}
+
+export function buildStatusCatalogFingerprint(
+  statuses: LinearStatusInput[],
+): string {
+  return hashWorkflowFingerprint(
+    statuses
+      .map((status) => ({
+        id: status.id,
+        name: status.name,
+        type: status.type,
+      }))
+      .sort((left, right) => left.id.localeCompare(right.id)),
+  );
+}
+
+export function sanitizeLinearColor(color: unknown): string | undefined {
+  if (typeof color !== "string") {
+    return undefined;
+  }
+  const trimmed = color.trim();
+  if (/^#[0-9a-fA-F]{3,8}$/.test(trimmed)) {
+    return trimmed;
+  }
+  return undefined;
+}

package/workspace-snapshot/files/src/workflow-page/model-catalog-lookup.ts

@@ -0,0 +1,8 @@
+import type { WorkflowModelCatalogEntry } from "./types.js";
+
+export function lookupModelInCatalog(
+  catalog: WorkflowModelCatalogEntry[],
+  modelId: string,
+): WorkflowModelCatalogEntry | undefined {
+  return catalog.find((entry) => entry.id === modelId);
+}

package/workspace-snapshot/files/src/workflow-page/model-catalog-utils.ts

@@ -0,0 +1,83 @@
+import type {
+  WorkflowModelCatalogEntry,
+  WorkflowModelParameterDefinition,
+} from "./types.js";
+import { hashWorkflowFingerprint } from "./fingerprint.js";
+
+interface RawCursorModel {
+  id: string;
+  name?: string;
+  displayName?: string;
+  parameters?: Array<{
+    id: string;
+    name?: string;
+    label?: string;
+    type?: string;
+    allowedValues?: string[];
+    defaultValue?: string;
+  }>;
+}
+
+function normalizeParameter(
+  parameter: NonNullable<RawCursorModel["parameters"]>[number],
+): WorkflowModelParameterDefinition {
+  const type =
+    parameter.type === "boolean" ||
+    parameter.type === "enum" ||
+    parameter.type === "string"
+      ? parameter.type
+      : parameter.allowedValues && parameter.allowedValues.length > 0
+        ? "enum"
+        : "string";
+
+  return {
+    id: parameter.id,
+    label: parameter.label ?? parameter.name ?? parameter.id,
+    type,
+    allowedValues: parameter.allowedValues,
+    defaultValue: parameter.defaultValue,
+  };
+}
+
+export function normalizeCursorModelCatalog(
+  models: RawCursorModel[],
+  source: "cursor-live" | "fixture",
+  fetchedAt: string,
+): WorkflowModelCatalogEntry[] {
+  return models.map((model) => ({
+    id: model.id,
+    displayName: model.displayName ?? model.name ?? model.id,
+    availability: "available" as const,
+    supportedParameters: (model.parameters ?? []).map(normalizeParameter),
+    fetchedAt,
+    source,
+  }));
+}
+
+export function buildCatalogUnavailableEntry(
+  source: "cursor-live" | "fixture",
+): WorkflowModelCatalogEntry[] {
+  return [
+    {
+      id: "catalog-unavailable",
+      displayName: "Model catalog unavailable",
+      availability: "catalog-unavailable",
+      supportedParameters: [],
+      source,
+    },
+  ];
+}
+
+export function buildModelCatalogFingerprint(
+  catalog: WorkflowModelCatalogEntry[],
+): string {
+  return hashWorkflowFingerprint(
+    catalog.map((entry) => ({
+      id: entry.id,
+      availability: entry.availability,
+      parameters: entry.supportedParameters.map((parameter) => parameter.id),
+    })),
+  );
+}
+
+export type { RawCursorModel };

package/workspace-snapshot/files/src/workflow-page/model-catalog.ts

@@ -0,0 +1,60 @@
+import type { HarnessConfig } from "../config/types.js";
+import type { CatalogLoadState, WorkflowModelCatalogEntry } from "./types.js";
+import {
+  buildCatalogUnavailableEntry,
+  normalizeCursorModelCatalog,
+  type RawCursorModel,
+} from "./model-catalog-utils.js";
+
+export {
+  buildCatalogUnavailableEntry,
+  buildModelCatalogFingerprint,
+  normalizeCursorModelCatalog,
+} from "./model-catalog-utils.js";
+export { lookupModelInCatalog } from "./model-catalog-lookup.js";
+
+export const WORKFLOW_MODEL_POLICY_NOTE =
+  "Planner and builder model selections are saved to harness.config.json roleModels and affect runtime agents.";
+
+export interface ModelCatalogLoadResult {
+  catalog: WorkflowModelCatalogEntry[];
+  loadState: CatalogLoadState;
+}
+
+export async function fetchLiveCursorModelCatalog(
+  apiKey: string,
+): Promise<ModelCatalogLoadResult> {
+  const fetchedAt = new Date().toISOString();
+  try {
+    const { Cursor } = await import("@cursor/sdk");
+    const models = (await Cursor.models.list({
+      apiKey: apiKey.trim(),
+    })) as RawCursorModel[];
+    return {
+      catalog: normalizeCursorModelCatalog(models, "cursor-live", fetchedAt),
+      loadState: "loaded",
+    };
+  } catch {
+    return {
+      catalog: buildCatalogUnavailableEntry("cursor-live"),
+      loadState: "unavailable",
+    };
+  }
+}
+
+export function emptyHarnessConfig(): HarnessConfig {
+  return {
+    version: 1,
+    orchestratorMarker: "harness-orchestrator-v1",
+    logDirectory: "runs",
+    repos: [
+      {
+        id: "target-app",
+        targetRepo: "https://github.com/weston-uribe/example-target-app",
+        baseBranch: "main",
+        productionBranch: "main",
+      },
+    ],
+    allowedTargetRepos: ["https://github.com/weston-uribe/example-target-app"],
+  };
+}

package/workspace-snapshot/files/src/workflow-page/scope-branches.ts

@@ -0,0 +1,27 @@
+import type { HarnessConfig } from "../config/types.js";
+import type { WorkflowScope } from "./types.js";
+
+export function resolveScopeBranchRelationship(input: {
+  scope: WorkflowScope;
+  config?: HarnessConfig;
+}): { baseBranch: string; productionBranch: string } {
+  const repoMapping = input.config?.repos.find((repo) => repo.id === input.scope.id);
+  return {
+    baseBranch: repoMapping?.baseBranch ?? "main",
+    productionBranch: repoMapping?.productionBranch ?? "main",
+  };
+}
+
+export function enrichWorkflowScopes(
+  scopes: WorkflowScope[],
+  config?: HarnessConfig,
+): WorkflowScope[] {
+  return scopes.map((scope) => {
+    const branches = resolveScopeBranchRelationship({ scope, config });
+    return {
+      ...scope,
+      baseBranch: branches.baseBranch,
+      productionBranch: branches.productionBranch,
+    };
+  });
+}

package/workspace-snapshot/files/src/workflow-page/source-context.ts

@@ -0,0 +1,91 @@
+import {
+  isWorkflowFixtureId,
+  P_DEV_OPERATIONS_FIXTURES_ENV,
+  P_DEV_WORKFLOW_FIXTURES_ENV,
+} from "./constants.js";
+import type { WorkflowSourceContext, WorkflowSourceMode } from "./types.js";
+
+export interface SourceContextRequest {
+  source?: string | null;
+  fixture?: string | null;
+  scope?: string | null;
+  fixturesEnabled?: boolean;
+}
+
+export function isFixturesOptInEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  return (
+    env[P_DEV_WORKFLOW_FIXTURES_ENV] === "1" ||
+    env[P_DEV_OPERATIONS_FIXTURES_ENV] === "1"
+  );
+}
+
+export function resolveWorkflowSourceContext(
+  request: SourceContextRequest,
+  env: NodeJS.ProcessEnv = process.env,
+): WorkflowSourceContext {
+  const fixturesEnabled = request.fixturesEnabled ?? isFixturesOptInEnabled(env);
+  const source = request.source?.trim().toLowerCase();
+  const fixture = request.fixture?.trim();
+  const scope = request.scope?.trim();
+
+  if (source === "fixture" || fixture) {
+    if (!fixturesEnabled) {
+      return {
+        mode: "fixture",
+        fixtureId: fixture,
+        fixturesEnabled: false,
+        rejectionReason:
+          "Fixture mode requires explicit server opt-in via P_DEV_WORKFLOW_FIXTURES=1 or P_DEV_OPERATIONS_FIXTURES=1.",
+      };
+    }
+
+    if (!fixture || !isWorkflowFixtureId(fixture)) {
+      return {
+        mode: "fixture",
+        fixtureId: fixture,
+        fixturesEnabled: true,
+        rejectionReason: fixture
+          ? `Unknown fixture id: ${fixture}`
+          : "Fixture id is required when source=fixture.",
+      };
+    }
+
+    return {
+      mode: "fixture",
+      fixtureId: fixture,
+      scopeId: scope,
+      fixturesEnabled: true,
+    };
+  }
+
+  return {
+    mode: "live",
+    scopeId: scope,
+    fixturesEnabled,
+  };
+}
+
+export function dataSourceLabel(context: WorkflowSourceContext): string {
+  if (context.rejectionReason) {
+    return "Unavailable";
+  }
+  if (context.mode === "fixture") {
+    return "Browser test fixture";
+  }
+  return "Live harness configuration";
+}
+
+export function assertWritableSourceContext(
+  context: WorkflowSourceContext,
+): WorkflowSourceContext {
+  if (context.rejectionReason) {
+    throw new Error(context.rejectionReason);
+  }
+  return context;
+}
+
+export function sourceModeFromContext(
+  context: WorkflowSourceContext,
+): WorkflowSourceMode {
+  return context.mode;
+}