p-dev-harness 0.3.1 → 0.4.0

package/workspace-snapshot/files/src/p-dev/package-paths.ts

@@ -1,11 +1,21 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 export const P_DEV_PACKAGE_NAME = "p-dev-harness";
+export const P_DEV_PACKAGE_ROOT_ENV = "P_DEV_PACKAGE_ROOT";
+
+export function normalizeModuleReferenceToPath(moduleUrl: string): string {
+  if (moduleUrl.startsWith("file://")) {
+    return fileURLToPath(moduleUrl);
+  }
+  return path.resolve(moduleUrl);
+}
 
 export function resolvePackageRootFromModule(moduleUrl: string): string {
-  let current = path.resolve(path.dirname(fileURLToPath(moduleUrl)));
+  let current = path.resolve(
+    path.dirname(normalizeModuleReferenceToPath(moduleUrl)),
+  );
 
   while (true) {
     const packageJsonPath = path.join(current, "package.json");
@@ -45,3 +55,63 @@ export function resolveTemplatesDirectory(packageRoot: string): string {
 export function resolveWorkspaceSnapshotDirectory(packageRoot: string): string {
   return path.join(packageRoot, "workspace-snapshot");
 }
+
+/**
+ * Validate an installed npm package root for packaged runtime.
+ * Does not use HARNESS_REPO_ROOT (operator workspace).
+ */
+export function validateInstalledPackageRoot(candidateRoot: string): string {
+  const packageRoot = path.resolve(candidateRoot);
+  const packageJsonPath = path.join(packageRoot, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    throw new Error(
+      `${P_DEV_PACKAGE_ROOT_ENV} is not a valid ${P_DEV_PACKAGE_NAME} package root (missing package.json): ${packageRoot}`,
+    );
+  }
+
+  let packageName: string | undefined;
+  try {
+    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8")) as {
+      name?: string;
+    };
+    packageName = parsed.name?.trim();
+  } catch {
+    throw new Error(
+      `${P_DEV_PACKAGE_ROOT_ENV} is not a valid ${P_DEV_PACKAGE_NAME} package root (unreadable package.json): ${packageRoot}`,
+    );
+  }
+
+  if (packageName !== P_DEV_PACKAGE_NAME) {
+    throw new Error(
+      `${P_DEV_PACKAGE_ROOT_ENV} must point to package name ${P_DEV_PACKAGE_NAME}, found ${packageName ?? "(missing)"} at ${packageRoot}`,
+    );
+  }
+
+  const snapshotDirectory = resolveWorkspaceSnapshotDirectory(packageRoot);
+  if (
+    !existsSync(snapshotDirectory) ||
+    !statSync(snapshotDirectory).isDirectory()
+  ) {
+    throw new Error(
+      `${P_DEV_PACKAGE_ROOT_ENV} is missing the workspace-snapshot directory at ${snapshotDirectory}`,
+    );
+  }
+
+  return packageRoot;
+}
+
+/**
+ * Resolve the installed package root from P_DEV_PACKAGE_ROOT.
+ * Required in packaged runtime; never falls back to import.meta.url walks.
+ */
+export function resolveInstalledPackageRootFromEnv(
+  env: NodeJS.ProcessEnv = process.env,
+): string {
+  const raw = env[P_DEV_PACKAGE_ROOT_ENV]?.trim();
+  if (!raw) {
+    throw new Error(
+      `${P_DEV_PACKAGE_ROOT_ENV} is required in packaged p-dev runtime.`,
+    );
+  }
+  return validateInstalledPackageRoot(raw);
+}

package/workspace-snapshot/files/src/p-dev/workspace-snapshot-generator.ts

@@ -1,5 +1,6 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { writeGitObjectPackFromManifestFiles } from "./git-object-plumbing.js";
 import {
   assertNoForbiddenSnapshotPaths,
   assertRequiredSnapshotPaths,
@@ -68,6 +69,26 @@ export async function generateWorkspaceSnapshot(
     });
   }
 
+  const blobContentsBySha = new Map(
+    snapshotEntries.map((entry) => [entry.gitBlobSha1, entry.content] as const),
+  );
+  const pack = writeGitObjectPackFromManifestFiles({
+    outputDir: path.join(input.outputDir, "object-pack"),
+    files: manifest.files,
+    blobContentsBySha,
+    expectedRootTreeSha: manifest.gitRootTreeSha1,
+  });
+  const packPath = path.relative(input.outputDir, pack.packPath);
+  const indexPath = path.relative(input.outputDir, pack.indexPath);
+  manifest.gitObjectPack = {
+    packPath,
+    indexPath,
+    packSha1: pack.packSha1,
+    packSha256: computeSnapshotFileSha256(await readFile(pack.packPath)),
+    objectCount: pack.objectCount,
+    packSizeBytes: pack.packSizeBytes,
+  };
+
   const manifestPath = path.join(input.outputDir, "manifest.json");
   await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
 

package/workspace-snapshot/files/src/p-dev/workspace-snapshot-manifest.ts

@@ -22,6 +22,48 @@ import {
 } from "./workspace-snapshot-digest.js";
 import type { GitCommitObjectEntry } from "./workspace-snapshot-git.js";
 
+function parseGitObjectPack(
+  value: unknown,
+): WorkspaceSnapshotManifest["gitObjectPack"] | undefined {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (!value || typeof value !== "object") {
+    throw new Error("Workspace snapshot gitObjectPack is invalid.");
+  }
+  const record = value as Record<string, unknown>;
+  if (
+    typeof record.packPath !== "string" ||
+    typeof record.indexPath !== "string" ||
+    !record.packPath.startsWith("object-pack/") ||
+    !record.indexPath.startsWith("object-pack/") ||
+    !record.packPath.endsWith(".pack") ||
+    !record.indexPath.endsWith(".idx")
+  ) {
+    throw new Error("Workspace snapshot gitObjectPack paths are invalid.");
+  }
+  if (typeof record.packSha1 !== "string" || !/^[0-9a-f]{40}$/.test(record.packSha1)) {
+    throw new Error("Workspace snapshot gitObjectPack is missing packSha1.");
+  }
+  if (typeof record.packSha256 !== "string" || !/^[0-9a-f]{64}$/.test(record.packSha256)) {
+    throw new Error("Workspace snapshot gitObjectPack is missing packSha256.");
+  }
+  if (typeof record.objectCount !== "number" || !Number.isFinite(record.objectCount)) {
+    throw new Error("Workspace snapshot gitObjectPack is missing objectCount.");
+  }
+  if (typeof record.packSizeBytes !== "number" || !Number.isFinite(record.packSizeBytes)) {
+    throw new Error("Workspace snapshot gitObjectPack is missing packSizeBytes.");
+  }
+  return {
+    packPath: record.packPath,
+    indexPath: record.indexPath,
+    packSha1: record.packSha1,
+    packSha256: record.packSha256,
+    objectCount: record.objectCount,
+    packSizeBytes: record.packSizeBytes,
+  };
+}
+
 export function buildWorkspaceSnapshotManifestFiles(
   entries: GitCommitObjectEntry[],
 ): WorkspaceSnapshotManifestFile[] {
@@ -263,6 +305,16 @@ export function parseWorkspaceSnapshotManifestJson(
     files.push(candidate);
   }
 
+  let gitObjectPack: WorkspaceSnapshotManifest["gitObjectPack"] | undefined;
+  try {
+    gitObjectPack = parseGitObjectPack(record.gitObjectPack);
+  } catch (error) {
+    return {
+      ok: false,
+      reason: error instanceof Error ? error.message : "Workspace snapshot gitObjectPack is invalid.",
+    };
+  }
+
   const manifest: WorkspaceSnapshotManifest = {
     schemaVersion: WORKSPACE_SNAPSHOT_SCHEMA_VERSION,
     product: WORKSPACE_SNAPSHOT_PRODUCT,
@@ -276,6 +328,7 @@ export function parseWorkspaceSnapshotManifestJson(
     gitRootTreeSha1: String(record.gitRootTreeSha1),
     fileCount: record.fileCount,
     generation: record.generation as WorkspaceSnapshotManifest["generation"],
+    gitObjectPack,
     files: sortSnapshotManifestFiles(files),
   };
 

package/workspace-snapshot/files/src/p-dev/workspace-snapshot-types.ts

@@ -47,6 +47,14 @@ export interface WorkspaceSnapshotManifest {
     modeSource: string;
     byteSource: string;
   };
+  gitObjectPack?: {
+    packPath: string;
+    indexPath: string;
+    packSha1: string;
+    packSha256: string;
+    objectCount: number;
+    packSizeBytes: number;
+  };
   files: WorkspaceSnapshotManifestFile[];
 }
 

package/workspace-snapshot/files/src/preview/preview-capability.ts

@@ -0,0 +1,21 @@
+/**
+ * Application preview capture (target-repo PR / production deployment polling)
+ * is separate from the PDev automation bridge hosted on Vercel.
+ */
+export function shouldCaptureApplicationPreview(
+  previewProvider: string | undefined | null,
+): boolean {
+  const normalized = previewProvider?.trim().toLowerCase();
+  return normalized !== undefined && normalized !== "" && normalized !== "none";
+}
+
+export function allReposSkipApplicationPreview(
+  repos: Array<{ previewProvider?: string }> | undefined,
+): boolean {
+  if (!repos?.length) {
+    return false;
+  }
+  return repos.every(
+    (repo) => !shouldCaptureApplicationPreview(repo.previewProvider),
+  );
+}

package/workspace-snapshot/files/src/product/initialization-state.ts

@@ -0,0 +1,65 @@
+import { parseProductMarkerJson } from "./product-marker.js";
+
+export type ProductInitializationState =
+  | "initialized"
+  | "uninitialized"
+  | "missing_marker"
+  | "invalid_marker";
+
+export interface ResolvedProductInitialization {
+  state: ProductInitializationState;
+  hasApprovedArchitecture: boolean;
+  reason?: string;
+}
+
+export function markerHasApprovedArchitecture(marker: {
+  approvedArchitecture?: {
+    platformRuntime?: string;
+    languageFramework?: string;
+  };
+}): boolean {
+  const architecture = marker.approvedArchitecture;
+  return Boolean(
+    architecture?.platformRuntime?.trim() && architecture?.languageFramework?.trim(),
+  );
+}
+
+export function resolveProductInitializationState(
+  markerContent: string | null,
+): ResolvedProductInitialization {
+  if (markerContent === null) {
+    return {
+      state: "missing_marker",
+      hasApprovedArchitecture: false,
+      reason: "Product marker not found on development branch.",
+    };
+  }
+
+  const parsed = parseProductMarkerJson(markerContent);
+  if (!parsed.ok) {
+    return {
+      state: "invalid_marker",
+      hasApprovedArchitecture: false,
+      reason: parsed.reason,
+    };
+  }
+
+  const hasApprovedArchitecture = markerHasApprovedArchitecture(parsed.marker);
+  if (parsed.marker.initializationStatus === "initialized") {
+    return {
+      state: "initialized",
+      hasApprovedArchitecture: hasApprovedArchitecture || true,
+    };
+  }
+
+  return {
+    state: "uninitialized",
+    hasApprovedArchitecture,
+  };
+}
+
+export function blocksDirectImplementationForInitialization(
+  initialization: ResolvedProductInitialization,
+): boolean {
+  return initialization.state === "uninitialized";
+}

package/workspace-snapshot/files/src/product/product-marker.ts

@@ -0,0 +1,76 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+
+export const PRODUCT_MARKER_PATH = ".p-dev/product.json";
+export const PRODUCT_README_PATH = "README.md";
+export const TARGET_REPO_MAIN_BRANCH = "main";
+export const TARGET_REPO_DEV_BRANCH = "dev";
+
+const approvedArchitectureSchema = z.object({
+  platformRuntime: z.string().min(1),
+  languageFramework: z.string().min(1),
+  repositoryStructure: z.string().optional(),
+  testingStrategy: z.string().optional(),
+  ciStrategy: z.string().optional(),
+});
+
+export const productMarkerSchema = z.object({
+  schemaVersion: z.literal(1),
+  createdBy: z.literal("p-dev"),
+  initializationStatus: z.enum(["uninitialized", "initialized"]),
+  createdAt: z.string().datetime(),
+  operationId: z.string().min(1),
+  creationActionId: z.string().min(1),
+  approvedArchitecture: approvedArchitectureSchema.optional(),
+});
+
+export type ProductMarkerV1 = z.infer<typeof productMarkerSchema>;
+
+export function buildProductReadme(productName: string): string {
+  return `# ${productName}
+
+This product repository was created by PDev.
+
+The product architecture has not been selected yet. Describe the product you want to build in Linear and begin with planning.
+`;
+}
+
+export function buildUninitializedProductMarker(input: {
+  createdAt: string;
+  operationId: string;
+  creationActionId: string;
+}): ProductMarkerV1 {
+  return {
+    schemaVersion: 1,
+    createdBy: "p-dev",
+    initializationStatus: "uninitialized",
+    createdAt: input.createdAt,
+    operationId: input.operationId,
+    creationActionId: input.creationActionId,
+  };
+}
+
+export function serializeProductMarker(marker: ProductMarkerV1): string {
+  return `${JSON.stringify(marker, null, 2)}\n`;
+}
+
+export function parseProductMarkerJson(
+  content: string,
+): { ok: true; marker: ProductMarkerV1 } | { ok: false; reason: string } {
+  try {
+    const parsed = productMarkerSchema.safeParse(JSON.parse(content));
+    if (!parsed.success) {
+      return {
+        ok: false,
+        reason: parsed.error.issues.map((issue) => issue.message).join("; "),
+      };
+    }
+    return { ok: true, marker: parsed.data };
+  } catch {
+    return { ok: false, reason: "Product marker is not valid JSON." };
+  }
+}
+
+export function hashProductMarkerContent(content: string): string {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}

package/workspace-snapshot/files/src/product/read-product-marker.ts

@@ -0,0 +1,63 @@
+import { GitHubClient } from "../github/client.js";
+import { normalizeRepoUrl } from "../resolver/normalize-repo.js";
+import {
+  PRODUCT_MARKER_PATH,
+  TARGET_REPO_DEV_BRANCH,
+} from "./product-marker.js";
+import type { GitHubTargetRepositoryProvider } from "../setup/github-target-repository-provider.js";
+
+export interface ReadProductMarkerInput {
+  targetRepo: string;
+  developmentBranch?: string;
+  github?: GitHubClient;
+  provider?: GitHubTargetRepositoryProvider;
+}
+
+export interface ReadProductMarkerResult {
+  content: string | null;
+  markerPath: string;
+  developmentBranch: string;
+}
+
+function parseOwnerRepo(targetRepo: string): { owner: string; repo: string } {
+  const normalized = normalizeRepoUrl(targetRepo);
+  const match = normalized.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)$/);
+  if (!match) {
+    throw new Error(`Invalid target repository URL: ${targetRepo}`);
+  }
+  return { owner: match[1]!, repo: match[2]! };
+}
+
+export async function readProductMarker(
+  input: ReadProductMarkerInput,
+): Promise<ReadProductMarkerResult> {
+  const developmentBranch = input.developmentBranch ?? TARGET_REPO_DEV_BRANCH;
+  const { owner, repo } = parseOwnerRepo(input.targetRepo);
+
+  if (input.provider) {
+    const content = await input.provider.readRepositoryFileContent(
+      owner,
+      repo,
+      PRODUCT_MARKER_PATH,
+      developmentBranch,
+    );
+    return { content, markerPath: PRODUCT_MARKER_PATH, developmentBranch };
+  }
+
+  if (!input.github) {
+    throw new Error("readProductMarker requires github client or provider");
+  }
+
+  const file = await input.github.getRepositoryContent(
+    owner,
+    repo,
+    PRODUCT_MARKER_PATH,
+    developmentBranch,
+  );
+
+  return {
+    content: file ? input.github.decodeRepositoryContent(file) : null,
+    markerPath: PRODUCT_MARKER_PATH,
+    developmentBranch,
+  };
+}

package/workspace-snapshot/files/src/prompts/builder.ts

@@ -31,17 +31,37 @@ export interface BuildImplementationPromptParams {
   branchName: string;
   planningCommentBody: string | null;
   validationCommands: string[];
+  productInitializationState?: string | null;
+}
+
+export interface BuildPlanningPromptParams {
+  issue: LinearIssueSnapshot;
+  parsed: ParsedIssue;
+  resolved: ResolvedTarget;
+  productInitializationState?: string | null;
 }
 
 export async function buildPlanningPrompt(
   issue: LinearIssueSnapshot,
   parsed: ParsedIssue,
   resolved: ResolvedTarget,
+  options?: { productInitializationState?: string | null },
 ): Promise<{ prompt: string; promptVersion: string }> {
   const template = await readFile(planningTemplatePath, "utf8");
   const validationSection = parsed.validationExpectations
     ? `### Validation expectations\n\n${parsed.validationExpectations}`
     : "";
+  const productFoundationSection = parsed.productFoundation
+    ? `### Product foundation\n\n${formatList(
+        Object.entries(parsed.productFoundation)
+          .filter(([, value]) => value)
+          .map(([key, value]) => `${key}: ${value}`),
+      )}`
+    : "";
+  const uninitializedSection =
+    options?.productInitializationState === "uninitialized"
+      ? "Target product is **uninitialized** — produce a foundation plan only."
+      : "";
 
   const prompt = template
     .replaceAll("{{promptVersion}}", PLANNING_PROMPT_VERSION)
@@ -50,7 +70,12 @@ export async function buildPlanningPrompt(
     .replaceAll("{{task}}", parsed.task)
     .replaceAll("{{acceptanceCriteria}}", formatList(parsed.acceptanceCriteria))
     .replaceAll("{{outOfScope}}", formatList(parsed.outOfScope))
-    .replaceAll("{{validationExpectations}}", validationSection)
+    .replaceAll(
+      "{{validationExpectations}}",
+      [validationSection, productFoundationSection, uninitializedSection]
+        .filter(Boolean)
+        .join("\n\n"),
+    )
     .replaceAll("{{targetRepo}}", resolved.targetRepo)
     .replaceAll("{{baseBranch}}", resolved.baseBranch);
 
@@ -67,6 +92,10 @@ export async function buildImplementationPrompt(
   const planningComment =
     params.planningCommentBody?.trim() ||
     "_No durable planning comment was found. Proceed only because the issue is narrow and well-scoped._";
+  const uninitializedProductContext =
+    params.productInitializationState === "uninitialized"
+      ? "Target product is uninitialized. Implementation must not proceed unless this is an approved foundation slice."
+      : "_Not applicable._";
 
   const prompt = template
     .replaceAll("{{promptVersion}}", IMPLEMENTATION_PROMPT_VERSION)
@@ -81,6 +110,7 @@ export async function buildImplementationPrompt(
     .replaceAll("{{baseBranch}}", params.resolved.baseBranch)
     .replaceAll("{{branchName}}", params.branchName)
     .replaceAll("{{planningComment}}", planningComment)
+    .replaceAll("{{uninitializedProductContext}}", uninitializedProductContext)
     .replaceAll("{{validationCommands}}", formatList(params.validationCommands))
     .replaceAll("{{runId}}", params.runId);
 

package/workspace-snapshot/files/src/prompts/implementation.md

@@ -18,6 +18,12 @@ You are the **implementation agent** for the agentic product development harness
 - Do not make unrelated changes.
 - Do not edit the harness repository unless it is the resolved target repo.
 
+## Uninitialized product guardrail (conditional)
+
+When the product marker on the development branch is `uninitialized`, stop unless this run is an approved foundation slice. Do not implement feature work before initialization completes.
+
+{{uninitializedProductContext}}
+
 ## Linear issue
 
 - **Key:** {{issueKey}}

package/workspace-snapshot/files/src/prompts/integration-repair.md

@@ -2,6 +2,12 @@
 
 You are the **integration repair agent** for the agentic product development harness.
 
+## Builder continuity
+
+- This is the **same Builder** that authored or revised the PR below.
+- The task is narrowly limited to integration repair on the existing PR branch.
+- Inspect the current PR branch state before editing.
+
 ## Mode: integration repair
 
 - Work only in the target repository below.

package/workspace-snapshot/files/src/prompts/planning.md

@@ -24,6 +24,14 @@ When the work touches a published artifact, deployment contract, persisted data
 
 Omit this section for internal prototype work with no distributable surface unless the issue explicitly asks for release analysis.
 
+## Uninitialized product foundation (conditional)
+
+When the target product marker is `uninitialized` or the issue includes `## Product foundation`:
+
+- Plan only the foundation PR that establishes approved architecture in `.p-dev/product.json`.
+- Do not plan feature delivery beyond initialization.
+- Keep deployment/provider assumptions technology-neutral.
+
 ## Linear issue
 
 - **Key:** {{issueKey}}

package/workspace-snapshot/files/src/prompts/revision.md

@@ -2,6 +2,13 @@
 
 You are the **revision agent** for the agentic product development harness.
 
+## Builder continuity
+
+- This is another run in the **same Builder conversation** that authored the implementation.
+- The implementation and PR below are the same work product.
+- PM feedback is the new instruction for this follow-up run.
+- Inspect the current branch and PR state before modifying code.
+
 ## Mode: revision
 
 - Work only in the target repository below.

package/workspace-snapshot/files/src/resolver/errors.ts

@@ -1,7 +1,9 @@
 export type ErrorClassification =
   | "ambiguous_issue"
   | "missing_target_repo"
-  | "unknown_repo_denied";
+  | "unknown_repo_denied"
+  | "linear_team_project_not_configured"
+  | "duplicate_delivery";
 
 export class ResolverError extends Error {
   readonly classification: ErrorClassification;

package/workspace-snapshot/files/src/resolver/target-repo.ts

@@ -3,10 +3,18 @@ import type { ParsedIssue } from "../types/parsed-issue.js";
 import { ResolverError } from "./errors.js";
 import { assertRepoAllowed } from "./allowed-repos.js";
 import { normalizeRepoUrl } from "./normalize-repo.js";
+import {
+  hasLinearAssociationsInConfig,
+  resolveLinearAssociationForIssue,
+} from "../config/resolve-linear-workspace.js";
+import { runLinearAssociationGate } from "../config/linear-association-gate.js";
 
 export interface IssueContext {
   projectName?: string;
   teamName?: string;
+  teamKey?: string;
+  teamId?: string;
+  projectId?: string;
 }
 
 export interface ResolvedTarget {
@@ -19,7 +27,7 @@ export interface ResolvedTarget {
   productionUrl?: string;
   integrationSuccessStatus?: string;
   productionSuccessStatus?: string;
-  resolutionSource: "explicit" | "project" | "team";
+  resolutionSource: "explicit" | "association" | "project" | "team";
 }
 
 export function resolveTargetRepo(
@@ -52,6 +60,57 @@ export function resolveTargetRepo(
     };
   }
 
+  if (hasLinearAssociationsInConfig(config)) {
+    const gate = runLinearAssociationGate({
+      config,
+      teamId: context.teamId,
+      teamKey: context.teamKey,
+      teamName: context.teamName,
+      projectId: context.projectId,
+    });
+    if (!gate.ok) {
+      throw new ResolverError(
+        gate.errorClassification as import("./errors.js").ErrorClassification,
+        gate.message,
+      );
+    }
+
+    const association = resolveLinearAssociationForIssue(config, {
+      teamId: context.teamId,
+      teamKey: context.teamKey,
+      teamName: context.teamName,
+      projectId: context.projectId,
+    });
+    if (!association) {
+      throw new ResolverError(
+        "linear_team_project_not_configured",
+        "linear_team_project_not_configured: no harness association matches issue team and project",
+      );
+    }
+
+    const mapping = config.repos.find((repo) => repo.id === association.repoConfigId);
+    if (!mapping) {
+      throw new ResolverError(
+        "missing_target_repo",
+        `No repo mapping found for association repo ${association.repoConfigId}`,
+      );
+    }
+
+    assertRepoAllowed(association.targetRepo, config);
+    return {
+      targetRepo: normalizeRepoUrl(association.targetRepo),
+      baseBranch: mapping.baseBranch,
+      productionBranch: mapping.productionBranch,
+      repoConfigId: mapping.id,
+      previewProvider: mapping.previewProvider ?? "none",
+      integrationPreviewUrl: mapping.integrationPreviewUrl,
+      productionUrl: mapping.productionUrl,
+      integrationSuccessStatus: mapping.integrationSuccessStatus,
+      productionSuccessStatus: mapping.productionSuccessStatus,
+      resolutionSource: "association",
+    };
+  }
+
   const byProject = findByProject(context.projectName, config);
   if (byProject) {
     assertRepoAllowed(byProject.targetRepo, config);