p-dev-harness 0.3.1 → 0.4.0

package/workspace-snapshot/files/src/setup/workflow-model-sync.ts

@@ -0,0 +1,259 @@
+import { mkdir, rename, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import type { HarnessConfig } from "../config/types.js";
+import type { RoleModelRole } from "../config/role-models.js";
+import { harnessConfigSchema } from "../config/schema.js";
+import { validateRepoClosure } from "../config/load-config.js";
+import {
+  generateHarnessConfigJsonB64,
+  readValidatedConfigLocalBytes,
+} from "./harness-secret-setup.js";
+import { formatHarnessDispatchRepo, resolveHarnessDispatchRepo } from "./harness-dispatch-repo.js";
+import { sanitizeGitHubSetupError } from "./github-remote-setup-live.js";
+import type { GitHubRemoteSetupProvider } from "./github-remote-provider.js";
+import { syncHarnessConfigCloudPair } from "./sync-harness-config-cloud.js";
+import { resolveLocalFilePaths } from "./setup-state.js";
+import { withWorkflowModelSyncLock } from "./workflow-model-sync-lock.js";
+import {
+  recordWorkflowModelsSyncEvidence,
+  type WorkflowModelsSyncEvidence,
+} from "./workflow-models-sync-evidence.js";
+import type { RoleModelSelection } from "../config/role-models.js";
+
+export type WorkflowModelSyncErrorCode =
+  | "workflow_model_fingerprint_mismatch"
+  | "workflow_model_catalog_unavailable"
+  | "workflow_model_validation_failed"
+  | "workflow_model_local_write_failed"
+  | "workflow_model_remote_write_failed"
+  | "workflow_model_sync_partial_failure"
+  | "workflow_model_sync_unknown";
+
+export class WorkflowModelSyncError extends Error {
+  constructor(
+    public readonly code: WorkflowModelSyncErrorCode,
+    message: string,
+  ) {
+    super(message);
+    this.name = "WorkflowModelSyncError";
+  }
+}
+
+export interface WorkflowModelSaveRequest {
+  role: RoleModelRole;
+  modelId: string;
+  params: Array<{ id: string; value: string }>;
+  expectedConfigFingerprint: string;
+}
+
+export interface WorkflowModelSaveResult {
+  saved: true;
+  role: RoleModelRole;
+  modelSelection: RoleModelSelection;
+  configFingerprint: string;
+  localConfigUpdated: true;
+  cloudConfigUpdated: true;
+  savedAt: string;
+  syncEvidenceWarning?: string;
+}
+
+function buildRoleModelSelection(input: {
+  modelId: string;
+  params: Array<{ id: string; value: string }>;
+}): RoleModelSelection {
+  return input.params.length
+    ? { id: input.modelId, params: input.params }
+    : { id: input.modelId };
+}
+
+async function writeConfigLocalAtomically(
+  cwd: string,
+  content: string,
+): Promise<void> {
+  const paths = resolveLocalFilePaths(cwd);
+  await mkdir(paths.harnessDir, { recursive: true });
+  const tempPath = `${paths.configLocal}.tmp-${process.pid}-${randomUUID()}`;
+  const normalized = content.endsWith("\n") ? content : `${content}\n`;
+  await writeFile(tempPath, normalized, "utf8");
+  await rename(tempPath, paths.configLocal);
+}
+
+async function mergeRoleModelIntoConfigBytes(input: {
+  priorBytes: Buffer;
+  role: RoleModelRole;
+  modelId: string;
+  params: Array<{ id: string; value: string }>;
+}): Promise<{ content: string; config: HarnessConfig }> {
+  const parsed = JSON.parse(input.priorBytes.toString("utf8")) as Record<string, unknown>;
+  const roleModels =
+    parsed.roleModels && typeof parsed.roleModels === "object"
+      ? { ...(parsed.roleModels as Record<string, unknown>) }
+      : {};
+  roleModels[input.role] = buildRoleModelSelection({
+    modelId: input.modelId,
+    params: input.params,
+  });
+  parsed.roleModels = roleModels;
+
+  const config = harnessConfigSchema.parse(parsed);
+  validateRepoClosure(config);
+  const content = `${JSON.stringify(config, null, 2)}\n`;
+  return { content, config };
+}
+
+async function restoreConfigLocalBytes(
+  cwd: string,
+  priorBytes: Buffer,
+): Promise<void> {
+  const paths = resolveLocalFilePaths(cwd);
+  const tempPath = `${paths.configLocal}.rollback-${process.pid}-${randomUUID()}`;
+  await writeFile(tempPath, priorBytes);
+  await rename(tempPath, paths.configLocal);
+  await readValidatedConfigLocalBytes(cwd);
+}
+
+function isDefiniteRemoteRejection(error: unknown): boolean {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const message = error.message.toLowerCase();
+  return (
+    message.includes("401") ||
+    message.includes("403") ||
+    message.includes("404") ||
+    message.includes("422") ||
+    message.includes("bad credentials") ||
+    message.includes("required for remote")
+  );
+}
+
+async function writeHarnessConfigSecretOnly(input: {
+  cwd?: string;
+  provider: GitHubRemoteSetupProvider;
+  encodedValue: string;
+}): Promise<{ harnessRepository: string; confirmed: true }> {
+  void input.encodedValue;
+  const harnessDispatchRepo = await resolveHarnessDispatchRepo({ cwd: input.cwd });
+  if (!harnessDispatchRepo.resolved || !harnessDispatchRepo.repo) {
+    throw new WorkflowModelSyncError(
+      "workflow_model_remote_write_failed",
+      "Harness dispatch repository is not configured.",
+    );
+  }
+
+  const harnessRepository = formatHarnessDispatchRepo(harnessDispatchRepo);
+
+  try {
+    await syncHarnessConfigCloudPair({
+      cwd: input.cwd,
+      provider: input.provider,
+      harnessRepository,
+    });
+    return { harnessRepository, confirmed: true };
+  } catch (error) {
+    throw new WorkflowModelSyncError(
+      error instanceof Error && isDefiniteRemoteRejection(error)
+        ? "workflow_model_remote_write_failed"
+        : "workflow_model_sync_unknown",
+      error instanceof Error
+        ? sanitizeGitHubSetupError(error)
+        : "Remote config secret write result is uncertain after retries.",
+    );
+  }
+}
+
+export async function saveWorkflowRoleModel(input: {
+  cwd: string;
+  request: WorkflowModelSaveRequest;
+  provider?: GitHubRemoteSetupProvider;
+}): Promise<WorkflowModelSaveResult> {
+  return withWorkflowModelSyncLock(input.cwd, async () => {
+    const { bytes: priorBytes, hash: currentFingerprint } =
+      await readValidatedConfigLocalBytes(input.cwd);
+
+    if (currentFingerprint !== input.request.expectedConfigFingerprint) {
+      throw new WorkflowModelSyncError(
+        "workflow_model_fingerprint_mismatch",
+        "Configuration changed since the page loaded. Reload and try again.",
+      );
+    }
+
+    const { content: nextContent } = await mergeRoleModelIntoConfigBytes({
+      priorBytes,
+      role: input.request.role,
+      modelId: input.request.modelId,
+      params: input.request.params,
+    });
+
+    await writeConfigLocalAtomically(input.cwd, nextContent);
+    const { bytes: updatedBytes, hash: updatedFingerprint } =
+      await readValidatedConfigLocalBytes(input.cwd);
+
+    if (!input.provider) {
+      await restoreConfigLocalBytes(input.cwd, priorBytes);
+      throw new WorkflowModelSyncError(
+        "workflow_model_remote_write_failed",
+        "GitHub credentials are required to synchronize workflow model settings.",
+      );
+    }
+
+    const encodedValue = generateHarnessConfigJsonB64(updatedBytes);
+
+    try {
+      const remote = await writeHarnessConfigSecretOnly({
+        cwd: input.cwd,
+        provider: input.provider,
+        encodedValue,
+      });
+
+      const savedAt = new Date().toISOString();
+      const evidence: WorkflowModelsSyncEvidence = {
+        configFingerprint: updatedFingerprint,
+        harnessRepository: remote.harnessRepository,
+        syncedAt: savedAt,
+      };
+
+      let syncEvidenceWarning: string | undefined;
+      try {
+        await recordWorkflowModelsSyncEvidence(evidence, input.cwd);
+      } catch {
+        syncEvidenceWarning =
+          "Model settings were synchronized, but local sync evidence could not be recorded. Run harness:doctor to verify.";
+      }
+
+      return {
+        saved: true,
+        role: input.request.role,
+        modelSelection: buildRoleModelSelection({
+          modelId: input.request.modelId,
+          params: input.request.params,
+        }),
+        configFingerprint: updatedFingerprint,
+        localConfigUpdated: true,
+        cloudConfigUpdated: true,
+        savedAt,
+        ...(syncEvidenceWarning ? { syncEvidenceWarning } : {}),
+      };
+    } catch (error) {
+      if (error instanceof WorkflowModelSyncError) {
+        if (error.code === "workflow_model_sync_unknown") {
+          throw error;
+        }
+        try {
+          await restoreConfigLocalBytes(input.cwd, priorBytes);
+        } catch {
+          throw new WorkflowModelSyncError(
+            "workflow_model_sync_partial_failure",
+            "Cloud synchronization failed and local configuration could not be restored automatically.",
+          );
+        }
+      }
+      throw error;
+    }
+  });
+}
+
+export async function readCurrentConfigFingerprint(cwd: string): Promise<string> {
+  const { hash } = await readValidatedConfigLocalBytes(cwd);
+  return hash;
+}

package/workspace-snapshot/files/src/setup/workflow-models-sync-evidence.ts

@@ -0,0 +1,34 @@
+import {
+  readControlPlaneSetupState,
+  updateControlPlaneSetupState,
+} from "./control-plane-setup-state.js";
+
+export interface WorkflowModelsSyncEvidence {
+  configFingerprint: string;
+  harnessRepository: string;
+  syncedAt: string;
+}
+
+export async function readWorkflowModelsSyncEvidence(
+  cwd?: string,
+): Promise<WorkflowModelsSyncEvidence | null> {
+  const state = await readControlPlaneSetupState(cwd);
+  return state?.workflowModels ?? null;
+}
+
+export async function recordWorkflowModelsSyncEvidence(
+  input: WorkflowModelsSyncEvidence,
+  cwd?: string,
+): Promise<void> {
+  await updateControlPlaneSetupState({ workflowModels: input }, cwd);
+}
+
+export function isWorkflowCloudConfigSynchronized(input: {
+  currentFingerprint: string;
+  evidence: WorkflowModelsSyncEvidence | null;
+}): boolean {
+  if (!input.evidence) {
+    return false;
+  }
+  return input.evidence.configFingerprint === input.currentFingerprint;
+}

package/workspace-snapshot/files/src/types/parsed-issue.ts

@@ -1,8 +1,17 @@
+export interface ProductFoundationFields {
+  platformRuntime?: string;
+  languageFramework?: string;
+  repositoryStructure?: string;
+  testingStrategy?: string;
+  ciStrategy?: string;
+}
+
 export interface ParsedIssue {
   targetRepoRaw?: string;
   task: string;
   acceptanceCriteria: string[];
   outOfScope: string[];
   validationExpectations?: string;
+  productFoundation?: ProductFoundationFields;
   parseErrors: string[];
 }

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

@@ -58,6 +58,16 @@ export type ErrorClassification =
   | "deployment_not_found"
   | "recovery_handoff"
   | "implementation_in_progress"
+  | "canonical_workflow_invalid"
+  | "linear_team_unresolved"
+  | "linear_team_mismatch"
+  | "linear_team_identity_missing"
+  | "canonical_workflow_load_failed"
+  | "linear_team_project_not_configured"
+  | "cloud_config_stale"
+  | "builder_lineage_integrity"
+  | "duplicate_delivery"
+  | "run_crash"
   | null;
 
 export interface RunManifest {
@@ -69,7 +79,7 @@ export interface RunManifest {
   linearStatusAfter: string | null;
   targetRepo: string | null;
   baseBranch: string | null;
-  resolutionSource: "explicit" | "project" | "team" | null;
+  resolutionSource: "explicit" | "association" | "project" | "team" | null;
   dryRun: boolean;
   finalOutcome: FinalOutcome;
   errorClassification: ErrorClassification;
@@ -94,6 +104,23 @@ export interface RunManifest {
   mergedAt: string | null;
   deploymentUrl: string | null;
   model: string | null;
+  modelRole?: "planner" | "builder" | null;
+  modelParams?: Array<{ id: string; value: string }> | null;
+  builderAgentId?: string | null;
+  builderThreadAction?: "created" | "resumed" | "replaced" | null;
+  builderThreadGeneration?: number | null;
+  builderOriginRunId?: string | null;
+  previousBuilderAgentId?: string | null;
+  builderThreadReplacementReason?:
+    | "legacy_missing_lineage"
+    | "agent_not_found"
+    | "agent_deleted"
+    | "agent_inaccessible"
+    | null;
+  cursorRequestId?: string | null;
+  deliveryId?: string | null;
+  runGeneration?: number | null;
+  runOwnedStatuses?: string[] | null;
 }
 
 export type RunEventName =
@@ -105,6 +132,7 @@ export type RunEventName =
   | "repo_resolved"
   | "repo_resolution_failed"
   | "phase_inferred"
+  | "canonical_workflow_preflight"
   | "idempotency_skip"
   | "planning_comment_loaded"
   | "implementation_comment_loaded"
@@ -123,6 +151,8 @@ export type RunEventName =
   | "validation_completed"
   | "github_pr_inspected"
   | "preview_poll_started"
+  | "preview_poll_skipped"
+  | "application_preview_not_configured"
   | "preview_captured"
   | "preview_not_found"
   | "handoff_comment_posted"
@@ -147,6 +177,19 @@ export type RunEventName =
   | "deployment_not_found"
   | "merge_comment_posted"
   | "merge_recovery_written"
+  | "builder_thread_resolved"
+  | "builder_thread_created"
+  | "builder_thread_resume_attempted"
+  | "builder_thread_resumed"
+  | "builder_thread_resume_failed"
+  | "builder_thread_unarchived"
+  | "builder_thread_replacement_created"
+  | "builder_thread_lineage_rejected"
+  | "builder_followup_run_started"
+  | "uninitialized_product_rerouted"
+  | "product_marker_loaded"
+  | "product_marker_skipped"
+  | "project_metadata_sync"
   | "run_finished";
 
 export interface RunEvent {

package/workspace-snapshot/files/src/validate/issue.ts

@@ -8,15 +8,18 @@ import { findLatestPlanningComment } from "../linear/planning-comment.js";
 import { createLinearClient, listIssueComments } from "../linear/writer.js";
 import { ResolverError } from "../resolver/errors.js";
 import { resolveTargetRepo } from "../resolver/target-repo.js";
-import {
-  getNarrowFailureReason,
-  isNarrowImplementationIssue,
-} from "../runner/idempotency.js";
 import type {
   IntendedPhase,
   IssueValidationResult,
   ValidateIssueOptions,
 } from "./types.js";
+import {
+  type ProductInitializationState,
+} from "../product/initialization-state.js";
+import {
+  getNarrowFailureReason,
+  isNarrowImplementationIssue,
+} from "../runner/idempotency.js";
 
 function buildRepairInstructions(
   result: Omit<
@@ -50,6 +53,18 @@ function buildRepairInstructions(
     }
   }
 
+  if (
+    result.blocksDirectImplementationForUninitializedProduct &&
+    intendedPhase === "implementation"
+  ) {
+    repairs.push(
+      "Product is uninitialized — complete product foundation planning before Ready for Build.",
+    );
+    repairs.push(
+      "Set Linear status to Ready for Planning and run the foundation planning issue first.",
+    );
+  }
+
   if (
     result.validForPlanning &&
     !result.validForDirectImplementation &&
@@ -86,6 +101,8 @@ function buildRoutingNotes(
   hasPlanningMarker: boolean,
   intendedPhase: IntendedPhase | null,
   resolutionSource: IssueValidationResult["resolutionSource"],
+  blocksDirectImplementationForUninitializedProduct: boolean,
+  productInitializationState: ProductInitializationState | null,
 ): string[] {
   const notes: string[] = [];
 
@@ -111,6 +128,16 @@ function buildRoutingNotes(
     notes.push("Durable planning comment found — broad issues may proceed to implementation.");
   }
 
+  if (blocksDirectImplementationForUninitializedProduct) {
+    notes.push(
+      "Target product is uninitialized — route foundation work through Ready for Planning first.",
+    );
+  }
+
+  if (productInitializationState === "initialized") {
+    notes.push("Target product marker reports initialized status.");
+  }
+
   if (intendedPhase === "implementation" && validForPlanning && !validForDirectImplementation) {
     notes.push("Recommended status should be Ready for Planning, not Ready for Build.");
   }
@@ -120,16 +147,24 @@ function buildRoutingNotes(
 
 export function computeIssueValidation(
   description: string,
-  context: { projectName?: string; teamName?: string },
+  context: {
+    projectName?: string;
+    teamName?: string;
+    teamKey?: string;
+    teamId?: string;
+    projectId?: string;
+  },
   config: HarnessConfig,
   options: {
     intendedPhase?: IntendedPhase;
     hasPlanningMarker?: boolean;
     planningMarkerMode: "file" | "issue";
+    productInitializationState?: ProductInitializationState | null;
   },
 ): IssueValidationResult {
   const intendedPhase = options.intendedPhase ?? null;
   const hasPlanningMarker = options.hasPlanningMarker ?? false;
+  const productInitializationState = options.productInitializationState ?? null;
   const parsed = parseIssueDescription(description);
   const parseErrors = [...parsed.parseErrors];
 
@@ -160,8 +195,12 @@ export function computeIssueValidation(
   const validForPlanning = parseErrors.length === 0 && resolverError === null;
   const narrowIssue = isNarrowImplementationIssue(parsed);
   const narrowFailureReason = getNarrowFailureReason(parsed);
+  const blocksDirectImplementationForUninitializedProduct =
+    productInitializationState === "uninitialized";
   const validForDirectImplementation =
-    validForPlanning && (narrowIssue || hasPlanningMarker);
+    validForPlanning &&
+    !blocksDirectImplementationForUninitializedProduct &&
+    (narrowIssue || hasPlanningMarker);
 
   const routingNotes = buildRoutingNotes(
     validForPlanning,
@@ -170,6 +209,8 @@ export function computeIssueValidation(
     hasPlanningMarker,
     intendedPhase,
     resolutionSource,
+    blocksDirectImplementationForUninitializedProduct,
+    productInitializationState,
   );
 
   const base = {
@@ -183,6 +224,8 @@ export function computeIssueValidation(
     narrowFailureReason,
     hasPlanningMarker,
     planningMarkerMode: options.planningMarkerMode,
+    productInitializationState,
+    blocksDirectImplementationForUninitializedProduct,
     routingNotes,
   };
 
@@ -241,6 +284,9 @@ export async function validateIssueFromLinear(
     {
       projectName: issue.projectName ?? undefined,
       teamName: issue.teamName ?? undefined,
+      teamKey: issue.teamKey ?? undefined,
+      teamId: issue.teamId ?? undefined,
+      projectId: issue.projectId ?? undefined,
     },
     config,
     {

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

@@ -1,5 +1,6 @@
 import type { ErrorClassification } from "../resolver/errors.js";
 import type { ResolvedTarget } from "../resolver/target-repo.js";
+import type { ProductInitializationState } from "../product/initialization-state.js";
 
 export type IntendedPhase = "planning" | "implementation";
 
@@ -16,6 +17,8 @@ export interface IssueValidationResult {
   narrowFailureReason: string | null;
   hasPlanningMarker: boolean;
   planningMarkerMode: "file" | "issue";
+  productInitializationState: ProductInitializationState | null;
+  blocksDirectImplementationForUninitializedProduct: boolean;
   routingNotes: string[];
   repairInstructions: string[];
 }

package/workspace-snapshot/files/src/webhook/dispatch-statuses.ts

@@ -1,26 +1,18 @@
+import {
+  CANONICAL_DISPATCH_TRIGGER_STATUS_NAMES,
+  isCanonicalDispatchTriggerStatusName,
+} from "../workflow/canonical-product-development-workflow.js";
+
 /**
  * Linear statuses that should trigger a GitHub repository_dispatch.
- * Aligned with harness.config.json linear.eligibleStatuses trigger entries.
+ * Derived from the canonical product-development workflow descriptor.
  */
-export const DISPATCH_TRIGGER_STATUSES = [
-  "Ready for Planning",
-  "Ready for Build",
-  "PR Open",
-  "Needs Revision",
-  "Ready to Merge",
-] as const;
+export const DISPATCH_TRIGGER_STATUSES = CANONICAL_DISPATCH_TRIGGER_STATUS_NAMES;
 
 export type DispatchTriggerStatus = (typeof DISPATCH_TRIGGER_STATUSES)[number];
 
-const NORMALIZED_DISPATCH_STATUSES = new Set(
-  DISPATCH_TRIGGER_STATUSES.map((status) => status.toLowerCase()),
-);
-
 export function isDispatchTriggerStatus(
   status: string | null | undefined,
 ): status is DispatchTriggerStatus {
-  if (!status) {
-    return false;
-  }
-  return NORMALIZED_DISPATCH_STATUSES.has(status.trim().toLowerCase());
+  return isCanonicalDispatchTriggerStatusName(status ?? "");
 }

package/workspace-snapshot/files/src/webhook/filter.ts

@@ -1,12 +1,21 @@
 import { isDispatchTriggerStatus } from "./dispatch-statuses.js";
+import type { HarnessConfig } from "../config/types.js";
+import { runLinearAssociationGate } from "../config/linear-association-gate.js";
 import type { ParsedLinearIssueWebhook } from "./types.js";
 
 export type FilterResult =
   | { dispatch: true }
-  | { dispatch: false; reason: "ignored_event" | "ignored_status" };
+  | {
+      dispatch: false;
+      reason:
+        | "ignored_event"
+        | "ignored_status"
+        | "linear_team_project_not_configured";
+    };
 
 export function shouldDispatchLinearIssueEvent(
   event: ParsedLinearIssueWebhook,
+  options?: { config?: HarnessConfig },
 ): FilterResult {
   if (event.eventType !== "Issue") {
     return { dispatch: false, reason: "ignored_event" };
@@ -25,6 +34,20 @@ export function shouldDispatchLinearIssueEvent(
     return { dispatch: false, reason: "ignored_status" };
   }
 
+  if (options?.config) {
+    const associationGate = runLinearAssociationGate({
+      config: options.config,
+      teamId: event.teamId,
+      projectId: event.projectId,
+    });
+    if (!associationGate.ok) {
+      return {
+        dispatch: false,
+        reason: "linear_team_project_not_configured",
+      };
+    }
+  }
+
   return { dispatch: true };
 }
 

package/workspace-snapshot/files/src/webhook/handle-linear-webhook.ts

@@ -3,6 +3,7 @@ import {
   getDispatchEventType,
   getDispatchRepository,
 } from "./dispatch-github.js";
+import { loadHarnessConfig } from "../config/load-config.js";
 import { shouldDispatchLinearIssueEvent } from "./filter.js";
 import {
   parseLinearIssueEvent,
@@ -50,6 +51,17 @@ function jsonResponse(
   return { status, body };
 }
 
+async function loadHarnessConfigForWebhook() {
+  try {
+    const loaded = await loadHarnessConfig({
+      configPath: process.env.HARNESS_CONFIG_PATH,
+    });
+    return loaded.config;
+  } catch {
+    return undefined;
+  }
+}
+
 export async function handleLinearWebhook(
   options: HandleLinearWebhookOptions,
 ): Promise<HandleLinearWebhookResult> {
@@ -108,7 +120,9 @@ export async function handleLinearWebhook(
     return jsonResponse(200, { accepted: false, reason: "ignored_event" });
   }
 
-  const filterResult = shouldDispatchLinearIssueEvent(parsed);
+  const filterResult = shouldDispatchLinearIssueEvent(parsed, {
+    config: await loadHarnessConfigForWebhook(),
+  });
   if (!filterResult.dispatch) {
     logWebhookEvent({
       linearDeliveryId: parsed.linearDeliveryId,

package/workspace-snapshot/files/src/webhook/parse-linear-issue-event.ts

@@ -10,6 +10,8 @@ interface LinearIssueData {
   identifier?: string;
   url?: string;
   state?: LinearStateLike | null;
+  team?: { id?: string | null } | null;
+  project?: { id?: string | null } | null;
 }
 
 interface LinearWebhookPayload {
@@ -81,6 +83,8 @@ export function parseLinearIssueEvent(
     issueKey,
     issueId: typeof data.id === "string" ? data.id : null,
     issueUrl,
+    teamId: typeof data.team?.id === "string" ? data.team.id : null,
+    projectId: typeof data.project?.id === "string" ? data.project.id : null,
     action: typeof body.action === "string" ? body.action : "",
     statusName,
     previousStatusName,