@remixhq/core 0.1.36 → 0.1.38

package/dist/api.d.ts

@@ -1,6 +1,6 @@
 import { CoreConfig } from './config.js';
 import { T as TokenProvider } from './tokenProvider-B9so5Pm3.js';
-import { T as TurnUsage } from './contracts-BqC3Lj7W.js';
+import { T as TurnUsage } from './contracts-DTeSJnoC.js';
 import 'zod';
 
 type HistoryImportProvider = "claude_code" | "cursor";
@@ -264,6 +264,50 @@ type SyncLocalResponse = {
     };
     warnings: string[];
 };
+type LocalCheckoutRecommendedAction = "pull" | "reconcile" | "await_finalize" | "record" | "no_action";
+type LocalAlignmentEventKind = "sync_local" | "reconcile_local";
+type ReportLocalCheckoutStatePayload = {
+    checkoutId: string;
+    collabLaneId?: string;
+    branch?: string;
+    repoFingerprint?: string;
+    localState?: string;
+    recommendedAction: LocalCheckoutRecommendedAction;
+    materializationStatus?: string;
+    alignmentRequired?: string;
+    baselineRevisionId?: string | null;
+    localRevisionId?: string | null;
+    serverRevisionId?: string | null;
+    localHeadHash?: string;
+    serverHeadCommitId?: string | null;
+    serverHeadHash?: string;
+    hasLocalChanges?: boolean;
+    hasUnrecordedChanges?: boolean;
+    pendingFinalizeCount?: number;
+    lastSeenAt?: string;
+    metadata?: Record<string, unknown>;
+};
+type RecordLocalAlignmentEventPayload = {
+    eventKind: LocalAlignmentEventKind;
+    branch?: string;
+    collabLaneId?: string;
+    baseRevisionId?: string | null;
+    targetRevisionId?: string | null;
+    resultRevisionId?: string | null;
+    baseHeadCommitId?: string | null;
+    baseHeadHash?: string;
+    targetHeadCommitId?: string | null;
+    targetHeadHash?: string;
+    resultHeadCommitId?: string | null;
+    resultHeadHash?: string;
+    changedFilesCount?: number;
+    insertions?: number;
+    deletions?: number;
+    localCommitCount?: number;
+    summary?: string;
+    idempotencyKey?: string;
+    metadata?: Record<string, unknown>;
+};
 type SyncUpstreamResponse = {
     status: "up-to-date" | "queued";
     mergeRequestId?: string;
@@ -1110,6 +1154,9 @@ type ApiClient = {
         defaultBranch?: string;
         dryRun?: boolean;
     }): Promise<Json>;
+    reportLocalCheckoutState(appId: string, payload: ReportLocalCheckoutStatePayload): Promise<Json>;
+    getLatestLocalCheckoutState(appId: string): Promise<Json>;
+    recordLocalAlignmentEvent(appId: string, payload: RecordLocalAlignmentEventPayload): Promise<Json>;
     initiateBundle(appId: string, payload: InitiateBundleRequest): Promise<Json>;
     getBundle(appId: string, bundleId: string): Promise<Json>;
     getBundleDownloadUrl(appId: string, bundleId: string, options?: {

package/dist/api.js

@@ -1,6 +1,6 @@
 import {
   createApiClient
-} from "./chunk-MNVBXTSV.js";
+} from "./chunk-QIESQM7X.js";
 import "./chunk-7XJGOKEO.js";
 export {
   createApiClient

package/dist/{chunk-MNVBXTSV.js → chunk-QIESQM7X.js}

@@ -548,6 +548,15 @@ function createApiClient(config, opts) {
       method: "POST",
       body: JSON.stringify(payload)
     }),
+    reportLocalCheckoutState: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/local-alignment/checkout-state`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    getLatestLocalCheckoutState: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/local-alignment/checkout-state/latest`, { method: "GET" }),
+    recordLocalAlignmentEvent: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/local-alignment/events`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
     initiateBundle: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/bundles`, { method: "POST", body: JSON.stringify(payload) }),
     getBundle: (appId, bundleId) => request(`/v1/apps/${encodeURIComponent(appId)}/bundles/${encodeURIComponent(bundleId)}`, { method: "GET" }),
     getBundleDownloadUrl: (appId, bundleId, options) => request(

package/dist/collab.d.ts

@@ -1,5 +1,5 @@
-import { C as CollabApiClient, a as TurnUsagePayload, b as CollabFinalizeTurnResult, c as CollabRecordingPreflight, d as CollabApproveMode, e as CollabApprovalStrategy, f as CollabApproveResult, M as MergeRequestQueue, g as MergeRequest, I as InvitationScopeType, h as CollabMember, A as AppProfileInput, J as JsonObject, i as AppDeltaResponse, j as CollabStatus, k as MergeRequestReview } from './contracts-BqC3Lj7W.js';
-export { l as AppHeadResponse, m as AppMember, n as AppMemberRole, o as AppReconcileResponse, p as CollabFinalizeTurnAutoSync, q as CollabFinalizeTurnMode, r as CollabPendingFinalizeState, s as CollabPendingFinalizeSummary, t as CollabRecordingPreflightStatus, u as CollabRepoStateKind, v as CollabStatusBlockedReason, w as CollabStatusRecommendedAction, x as CollabTurn, y as MembershipScopeType, z as MergeRequestStatus, B as ModelCall, O as OrganizationMember, D as OrganizationMemberRole, P as ProjectMember, E as ProjectMemberRole, R as ReconcilePreflightResponse, S as ServerToolUsage, F as SyncLocalResponse, G as SyncUpstreamResponse, T as TurnUsage, H as TurnUsageCaptureSource, K as TurnUsageConfidence, L as TurnUsagePreviousPatch } from './contracts-BqC3Lj7W.js';
+import { C as CollabApiClient, a as TurnUsagePayload, b as CollabFinalizeTurnResult, c as CollabRecordingPreflight, d as CollabApproveMode, e as CollabApprovalStrategy, f as CollabApproveResult, M as MergeRequestQueue, g as MergeRequest, I as InvitationScopeType, h as CollabMember, A as AppProfileInput, J as JsonObject, i as AppDeltaResponse, j as CollabStatus, k as MergeRequestReview } from './contracts-DTeSJnoC.js';
+export { l as AppHeadResponse, m as AppMember, n as AppMemberRole, o as AppReconcileResponse, p as CollabFinalizeTurnAutoSync, q as CollabFinalizeTurnMode, r as CollabPendingFinalizeState, s as CollabPendingFinalizeSummary, t as CollabRecordingPreflightStatus, u as CollabRepoStateKind, v as CollabStatusBlockedReason, w as CollabStatusRecommendedAction, x as CollabTurn, y as MembershipScopeType, z as MergeRequestStatus, B as ModelCall, O as OrganizationMember, D as OrganizationMemberRole, P as ProjectMember, E as ProjectMemberRole, R as ReconcilePreflightResponse, S as ServerToolUsage, F as SyncLocalResponse, G as SyncUpstreamResponse, T as TurnUsage, H as TurnUsageCaptureSource, K as TurnUsageConfidence, L as TurnUsagePreviousPatch } from './contracts-DTeSJnoC.js';
 import { B as BranchBindingMode } from './binding-WiIRI2fl.js';
 
 declare function collabFinalizeTurn(params: {
@@ -154,12 +154,15 @@ declare function collabApprove(params: {
     allowBranchMismatch?: boolean;
 }): Promise<CollabApproveResult>;
 
+type CheckoutPhase = "downloading" | "unpacking" | "finalizing";
+
 declare function collabCheckout(params: {
     api: CollabApiClient;
     cwd: string;
     appId?: string | null;
     outputDir?: string | null;
     skipLaneMaterialization?: boolean;
+    onPhase?: (phase: CheckoutPhase) => void;
 }): Promise<{
     appId: string;
     dashboardUrl: string;
@@ -391,6 +394,7 @@ declare function collabRemix(params: {
     appId?: string | null;
     name?: string | null;
     outputDir?: string | null;
+    onPhase?: (phase: CheckoutPhase) => void;
 }): Promise<{
     appId: string;
     dashboardUrl: string;

package/dist/collab.js

@@ -952,6 +952,25 @@ function matchesJobScope(job, scope) {
   if (scope.repoFingerprint && job.repoFingerprint && job.repoFingerprint !== scope.repoFingerprint) return false;
   return true;
 }
+function isSameProcessingScope(left, right) {
+  return left.id !== right.id && left.repoRoot === right.repoRoot && left.currentAppId === right.currentAppId && (left.laneId ?? null) === (right.laneId ?? null) && (left.repoFingerprint ?? null) === (right.repoFingerprint ?? null);
+}
+async function hasFreshJobLock(jobId) {
+  try {
+    const stat = await fs4.stat(getJobLockPath2(jobId));
+    return Date.now() - stat.mtimeMs < FINALIZE_JOB_LOCK_STALE_MS;
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function blocksFinalizeClaim(candidate, blocker) {
+  if (!isSameProcessingScope(candidate, blocker)) return false;
+  if (blocker.status === "processing") return hasFreshJobLock(blocker.id);
+  return blocker.status === "queued" && isPastDue(blocker.nextRetryAt) && blocker.capturedAt < candidate.capturedAt;
+}
 function createEmptyPendingFinalizeQueueSummary() {
   return {
     state: "idle",
@@ -1225,6 +1244,13 @@ async function claimPendingFinalizeJob(jobId) {
       await release();
       return null;
     }
+    const jobs = await listPendingFinalizeJobs();
+    for (const job of jobs) {
+      if (await blocksFinalizeClaim(existing, job)) {
+        await release();
+        return null;
+      }
+    }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const claimed = await updatePendingFinalizeJob(jobId, {
       status: "processing",
@@ -2710,6 +2736,188 @@ function validateSucceededChangeStepForBaseline(params) {
   };
 }
 
+// src/infrastructure/collab/checkoutIdentityStore.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import fs5 from "fs/promises";
+import path6 from "path";
+function getCheckoutIdentityPath(params) {
+  return path6.join(getCollabStateRoot(), "checkouts", `${buildLaneStateKey(params)}.json`);
+}
+async function getCheckoutIdentity(params) {
+  const filePath = getCheckoutIdentityPath(params);
+  try {
+    const raw = await fs5.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const checkoutId = typeof parsed?.checkoutId === "string" ? parsed.checkoutId.trim() : "";
+    if (checkoutId) return checkoutId;
+  } catch {
+  }
+  const next = {
+    schemaVersion: 1,
+    checkoutId: randomUUID4(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeJsonAtomic(filePath, next);
+  return next.checkoutId;
+}
+
+// src/application/collab/localAlignmentReporting.ts
+function toCheckoutAction(action) {
+  if (action === "pull" || action === "reconcile" || action === "await_finalize" || action === "record") return action;
+  return "no_action";
+}
+function actionForRepoState(repoState) {
+  if (repoState === "server_only_changed") return "pull";
+  if (repoState === "both_changed" || repoState === "external_local_base_changed" || repoState === "baseline_missing") {
+    return "reconcile";
+  }
+  if (repoState === "local_only_changed") return "record";
+  return "no_action";
+}
+function alignmentRequiredForAction(action) {
+  if (action === "pull") return "sync";
+  if (action === "reconcile") return "reconcile";
+  if (action === "await_finalize") return "finalize";
+  if (action === "record") return "record";
+  return void 0;
+}
+async function reportCheckoutState(params) {
+  try {
+    const checkoutId = await getCheckoutIdentity({
+      repoRoot: params.repoRoot,
+      repoFingerprint: params.repoFingerprint ?? null,
+      laneId: params.laneId ?? null
+    });
+    await params.api.reportLocalCheckoutState(params.appId, {
+      checkoutId,
+      collabLaneId: params.laneId ?? void 0,
+      branch: params.branch ?? void 0,
+      repoFingerprint: params.repoFingerprint ?? void 0,
+      localState: params.localState ?? void 0,
+      recommendedAction: params.recommendedAction,
+      materializationStatus: params.materializationStatus ?? void 0,
+      alignmentRequired: params.alignmentRequired ?? alignmentRequiredForAction(params.recommendedAction),
+      baselineRevisionId: params.baselineRevisionId,
+      localRevisionId: params.localRevisionId,
+      serverRevisionId: params.serverRevisionId,
+      localHeadHash: params.localHeadHash ?? void 0,
+      serverHeadCommitId: params.serverHeadCommitId,
+      serverHeadHash: params.serverHeadHash ?? void 0,
+      hasLocalChanges: params.hasLocalChanges,
+      hasUnrecordedChanges: params.hasUnrecordedChanges,
+      pendingFinalizeCount: params.pendingFinalizeCount,
+      metadata: params.metadata
+    });
+    return { warnings: [] };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err ?? "unknown error");
+    return { warnings: [`Failed to report local checkout state: ${message}`] };
+  }
+}
+async function reportCheckoutStateFromStatus(params) {
+  const { api, status } = params;
+  const repoRoot = status.repo.repoRoot;
+  const appId = status.binding.currentAppId;
+  if (!api || !repoRoot || !appId) return { warnings: [] };
+  return reportCheckoutState({
+    api,
+    appId,
+    repoRoot,
+    repoFingerprint: status.binding.repoFingerprint,
+    laneId: status.binding.laneId,
+    branch: status.repo.branch ?? status.binding.branchName,
+    localState: status.alignment.repoState,
+    recommendedAction: toCheckoutAction(status.recommendedAction),
+    materializationStatus: status.alignment.checked ? "checked" : void 0,
+    baselineRevisionId: status.alignment.baseline.lastServerRevisionId,
+    serverRevisionId: status.alignment.current.serverRevisionId,
+    localHeadHash: status.alignment.current.localCommitHash ?? status.repo.headCommitHash,
+    serverHeadCommitId: status.alignment.current.serverHeadCommitId,
+    serverHeadHash: status.alignment.current.serverHeadHash,
+    hasLocalChanges: status.alignment.repoState === "local_only_changed" || status.alignment.repoState === "both_changed",
+    hasUnrecordedChanges: status.alignment.repoState === "local_only_changed" || status.alignment.repoState === "both_changed",
+    pendingFinalizeCount: status.alignment.pendingFinalize.activeJobCount,
+    metadata: {
+      source: params.source,
+      branchMismatch: status.repo.branchMismatch
+    }
+  });
+}
+async function reportAlignedCheckoutState(params) {
+  return reportCheckoutState({
+    api: params.api,
+    appId: params.appId,
+    repoRoot: params.repoRoot,
+    repoFingerprint: params.repoFingerprint,
+    laneId: params.laneId,
+    branch: params.branch,
+    localState: "idle",
+    recommendedAction: "no_action",
+    materializationStatus: "applied",
+    baselineRevisionId: params.baselineRevisionId,
+    serverRevisionId: params.serverRevisionId,
+    localHeadHash: params.localHeadHash,
+    serverHeadCommitId: params.serverHeadCommitId,
+    serverHeadHash: params.serverHeadHash,
+    hasLocalChanges: false,
+    hasUnrecordedChanges: false,
+    pendingFinalizeCount: 0,
+    metadata: { source: params.source }
+  });
+}
+async function reportCheckoutStateFromFinalize(params) {
+  const recommendedAction = params.materializationStatus.startsWith("queued") ? "await_finalize" : actionForRepoState(params.repoState);
+  const hasLocalChanges = params.repoState === "local_only_changed" || params.repoState === "both_changed";
+  return reportCheckoutState({
+    api: params.api,
+    appId: params.appId,
+    repoRoot: params.repoRoot,
+    repoFingerprint: params.repoFingerprint,
+    laneId: params.laneId,
+    branch: params.branch,
+    localState: params.repoState,
+    recommendedAction,
+    materializationStatus: params.materializationStatus,
+    alignmentRequired: params.alignmentRequired,
+    baselineRevisionId: params.baselineRevisionId,
+    serverRevisionId: params.serverRevisionId,
+    localHeadHash: params.localHeadHash,
+    serverHeadCommitId: params.serverHeadCommitId,
+    serverHeadHash: params.serverHeadHash,
+    hasLocalChanges,
+    hasUnrecordedChanges: recommendedAction === "record" || recommendedAction === "reconcile",
+    pendingFinalizeCount: params.pendingFinalizeCount,
+    metadata: { source: params.source }
+  });
+}
+async function recordLocalAlignmentEvent(params) {
+  try {
+    await params.api.recordLocalAlignmentEvent(params.appId, {
+      eventKind: params.eventKind,
+      branch: params.branch,
+      collabLaneId: params.collabLaneId ?? void 0,
+      baseRevisionId: params.baseRevisionId,
+      targetRevisionId: params.targetRevisionId,
+      resultRevisionId: params.resultRevisionId,
+      baseHeadHash: params.baseHeadHash ?? void 0,
+      targetHeadCommitId: params.targetHeadCommitId,
+      targetHeadHash: params.targetHeadHash ?? void 0,
+      resultHeadHash: params.resultHeadHash ?? void 0,
+      changedFilesCount: params.changedFilesCount,
+      insertions: params.insertions,
+      deletions: params.deletions,
+      localCommitCount: params.localCommitCount,
+      summary: params.summary,
+      idempotencyKey: params.idempotencyKey,
+      metadata: { source: params.eventKind }
+    });
+    return { warnings: [] };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err ?? "unknown error");
+    return { warnings: [`Failed to record local alignment event: ${message}`] };
+  }
+}
+
 // src/application/collab/collabFinalizeProcessing.ts
 var FINALIZE_RETRY_BASE_DELAY_MS = 15e3;
 var FINALIZE_RETRY_MAX_DELAY_MS = 5 * 60 * 1e3;
@@ -2834,6 +3042,23 @@ async function writeBaselineFromSucceededChangeStep(params) {
     lastSeenLocalCommitHash: params.snapshot.localCommitHash
   });
 }
+async function reportCompletedFinalizeCheckoutState(params) {
+  const result = await reportAlignedCheckoutState({
+    api: params.api,
+    appId: params.job.currentAppId,
+    repoRoot: params.job.repoRoot,
+    repoFingerprint: params.job.repoFingerprint,
+    laneId: params.job.laneId,
+    branch: params.job.branchName,
+    baselineRevisionId: params.serverRevisionId,
+    serverRevisionId: params.serverRevisionId,
+    localHeadHash: params.snapshot.localCommitHash,
+    serverHeadCommitId: params.serverHeadCommitId,
+    serverHeadHash: params.serverHeadHash,
+    source: params.source
+  });
+  return result.warnings;
+}
 async function harvestPreTurnEvents(repoRoot, fromCommit, toCommit) {
   if (!toCommit) return null;
   try {
@@ -3002,6 +3227,15 @@ async function processClaimedPendingFinalizeJobInner(params) {
       status: "completed",
       metadata: { collabTurnId: collabTurn.id }
     });
+    const reportWarnings2 = await reportCompletedFinalizeCheckoutState({
+      api: params.api,
+      job,
+      snapshot,
+      serverRevisionId: appHead.headRevisionId ?? null,
+      serverHeadCommitId: appHead.headCommitId,
+      serverHeadHash: appHead.headCommitHash,
+      source: "finalize_no_diff_turn"
+    });
     return {
       mode: "no_diff_turn",
       idempotencyKey: job.idempotencyKey ?? "",
@@ -3011,7 +3245,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
       changeStep: null,
       collabTurn,
       autoSync: null,
-      warnings: []
+      warnings: reportWarnings2
     };
   }
   const localBaselineAdvanced = baseline.lastSnapshotId !== job.baselineSnapshotId;
@@ -3062,6 +3296,15 @@ async function processClaimedPendingFinalizeJobInner(params) {
           changeStepId: String(changeStep2.id ?? "")
         }
       });
+      const reportWarnings2 = await reportCompletedFinalizeCheckoutState({
+        api: params.api,
+        job,
+        snapshot,
+        serverRevisionId: String(changeStep2.resultRevisionId ?? "") || null,
+        serverHeadCommitId: String(changeStep2.commitId ?? "") || null,
+        serverHeadHash: String(changeStep2.headCommitHash ?? "") || null,
+        source: "finalize_changed_turn"
+      });
       return {
         mode: "changed_turn",
         idempotencyKey: job.idempotencyKey ?? "",
@@ -3071,7 +3314,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
         changeStep: changeStep2,
         collabTurn: null,
         autoSync: null,
-        warnings: []
+        warnings: reportWarnings2
       };
     }
   }
@@ -3179,6 +3422,15 @@ async function processClaimedPendingFinalizeJobInner(params) {
       changeStepId: String(changeStep.id ?? "")
     }
   });
+  const reportWarnings = await reportCompletedFinalizeCheckoutState({
+    api: params.api,
+    job,
+    snapshot,
+    serverRevisionId: String(changeStep.resultRevisionId ?? "") || null,
+    serverHeadCommitId: String(changeStep.commitId ?? "") || null,
+    serverHeadHash: String(changeStep.headCommitHash ?? "") || null,
+    source: "finalize_changed_turn"
+  });
   return {
     mode: "changed_turn",
     idempotencyKey: job.idempotencyKey ?? "",
@@ -3188,7 +3440,7 @@ async function processClaimedPendingFinalizeJobInner(params) {
     changeStep,
     collabTurn: null,
     autoSync: null,
-    warnings: []
+    warnings: reportWarnings
   };
 }
 async function processPendingFinalizeJob(params) {
@@ -3396,6 +3648,23 @@ async function recordConversationOnlyTurn(params) {
     idempotencyKey
   });
   const collabTurn = unwrapResponseObject(collabTurnResp, "collab turn");
+  const reportResult = await reportCheckoutStateFromFinalize({
+    api: params.api,
+    appId: params.binding.currentAppId,
+    repoRoot: params.repoRoot,
+    repoFingerprint: params.binding.repoFingerprint,
+    laneId: params.binding.laneId,
+    branch: params.binding.branchName,
+    repoState: params.repoState,
+    materializationStatus: params.materializationStatus,
+    alignmentRequired: params.alignmentRequired,
+    baselineRevisionId: params.baselineServerRevisionId,
+    serverRevisionId: params.currentServerRevisionId,
+    localHeadHash: params.localCommitHash,
+    serverHeadCommitId: params.currentServerHeadCommitId,
+    serverHeadHash: params.currentServerHeadHash,
+    source: "finalize_conversation_only"
+  });
   return {
     mode: "conversation_only",
     idempotencyKey,
@@ -3405,7 +3674,7 @@ async function recordConversationOnlyTurn(params) {
     changeStep: null,
     collabTurn,
     autoSync: null,
-    warnings: [CONVERSATION_ONLY_WARNING, ...collectWarnings(params.warnings ?? [])]
+    warnings: [CONVERSATION_ONLY_WARNING, ...collectWarnings(params.warnings ?? []), ...reportResult.warnings]
   };
 }
 async function collabFinalizeTurn(params) {
@@ -3668,6 +3937,24 @@ async function collabFinalizeTurn(params) {
     },
     nextRetryAt
   });
+  const reportResult = await reportCheckoutStateFromFinalize({
+    api: params.api,
+    appId: binding.currentAppId,
+    repoRoot,
+    repoFingerprint: binding.repoFingerprint,
+    laneId: binding.laneId,
+    branch: binding.branchName,
+    repoState: detected.repoState,
+    materializationStatus: "queued_finalize",
+    alignmentRequired: "finalize",
+    baselineRevisionId: baseline.lastServerRevisionId,
+    serverRevisionId: detected.currentServerRevisionId,
+    localHeadHash: snapshot.localCommitHash,
+    serverHeadCommitId: detected.currentServerHeadCommitId,
+    serverHeadHash: detected.currentServerHeadHash,
+    pendingFinalizeCount: 1,
+    source: "finalize_queue"
+  });
   return {
     mode,
     idempotencyKey,
@@ -3677,7 +3964,7 @@ async function collabFinalizeTurn(params) {
     changeStep: null,
     collabTurn: null,
     autoSync: null,
-    warnings: [FINALIZE_QUEUED_WARNING, ...collectWarnings([...pendingFinalizeDrainWarnings, ...detected.warnings])]
+    warnings: [FINALIZE_QUEUED_WARNING, ...collectWarnings([...pendingFinalizeDrainWarnings, ...detected.warnings]), ...reportResult.warnings]
   };
 }
 
@@ -3773,9 +4060,9 @@ async function collabRecordingPreflight(params) {
 }
 
 // src/infrastructure/locking/repoMutationLock.ts
-import fs5 from "fs/promises";
+import fs6 from "fs/promises";
 import os3 from "os";
-import path6 from "path";
+import path7 from "path";
 var DEFAULT_ACQUIRE_TIMEOUT_MS = 15e3;
 var DEFAULT_STALE_MS = 45e3;
 var DEFAULT_HEARTBEAT_MS = 5e3;
@@ -3798,12 +4085,12 @@ function createOwner(params) {
   };
 }
 async function writeOwnerMetadata(ownerPath, owner) {
-  await fs5.writeFile(ownerPath, `${JSON.stringify(owner, null, 2)}
+  await fs6.writeFile(ownerPath, `${JSON.stringify(owner, null, 2)}
 `, "utf8");
 }
 async function readOwnerMetadata(ownerPath) {
   try {
-    const raw = await fs5.readFile(ownerPath, "utf8");
+    const raw = await fs6.readFile(ownerPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") return null;
     if (!parsed.operation || !parsed.repoRoot || typeof parsed.pid !== "number" || !parsed.startedAt || !parsed.heartbeatAt) {
@@ -3840,23 +4127,23 @@ async function getLastKnownUpdateMs(lockDir, ownerPath, owner) {
   if (Number.isFinite(heartbeatMs)) return heartbeatMs;
   const startedMs = owner ? Date.parse(owner.startedAt) : Number.NaN;
   if (Number.isFinite(startedMs)) return startedMs;
-  const stat = await fs5.stat(ownerPath).catch(() => null);
+  const stat = await fs6.stat(ownerPath).catch(() => null);
   if (stat) return stat.mtimeMs;
-  const dirStat = await fs5.stat(lockDir).catch(() => null);
+  const dirStat = await fs6.stat(lockDir).catch(() => null);
   if (dirStat) return dirStat.mtimeMs;
   return 0;
 }
 async function ensureLockDir(lockDir) {
-  await fs5.mkdir(path6.dirname(lockDir), { recursive: true });
+  await fs6.mkdir(path7.dirname(lockDir), { recursive: true });
 }
 async function tryAcquireLock(lockDir, ownerPath, owner) {
   try {
     await ensureLockDir(lockDir);
-    await fs5.mkdir(lockDir);
+    await fs6.mkdir(lockDir);
     try {
       await writeOwnerMetadata(ownerPath, owner);
     } catch (error) {
-      await fs5.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
+      await fs6.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
       throw error;
     }
     return true;
@@ -3906,7 +4193,7 @@ async function acquirePhysicalLock(lockDir, ownerPath, owner, options) {
     const alive = await isProcessAlive(currentOwner2);
     if (ageMs >= options.staleMs && alive !== true) {
       notices.push(buildStaleRecoveryNotice(currentOwner2));
-      await fs5.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
+      await fs6.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
       continue;
     }
     await sleep2(RETRY_DELAY_MS);
@@ -3931,7 +4218,7 @@ function startHeartbeat(lockDir, ownerPath, owner, heartbeatMs) {
     };
     owner.heartbeatAt = nextOwner.heartbeatAt;
     void writeOwnerMetadata(ownerPath, nextOwner).catch(() => void 0);
-    void fs5.utimes(lockDir, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date()).catch(() => void 0);
+    void fs6.utimes(lockDir, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date()).catch(() => void 0);
   }, heartbeatMs);
 }
 async function releaseReentrantLock(lockDir) {
@@ -3941,12 +4228,12 @@ async function releaseReentrantLock(lockDir) {
   if (held.count > 0) return;
   clearInterval(held.heartbeatTimer);
   heldLocks.delete(lockDir);
-  await fs5.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
+  await fs6.rm(lockDir, { recursive: true, force: true }).catch(() => void 0);
 }
 async function withRepoMutationLock(options, fn) {
   const repoRoot = await findGitRoot(options.cwd);
   const gitCommonDir = await getGitCommonDir(repoRoot);
-  const lockDir = path6.join(gitCommonDir, "remix", "locks", "repo-mutation.lock");
+  const lockDir = path7.join(gitCommonDir, "remix", "locks", "repo-mutation.lock");
   const owner = createOwner({
     operation: options.operation,
     repoRoot,
@@ -3958,11 +4245,11 @@ async function withRepoMutationLock(options, fn) {
   const existing = heldLocks.get(lockDir);
   let notices = [];
   if (!existing) {
-    notices = await acquirePhysicalLock(lockDir, path6.join(lockDir, "owner.json"), owner, {
+    notices = await acquirePhysicalLock(lockDir, path7.join(lockDir, "owner.json"), owner, {
       acquireTimeoutMs,
       staleMs
     });
-    const ownerPath = path6.join(lockDir, "owner.json");
+    const ownerPath = path7.join(lockDir, "owner.json");
     heldLocks.set(lockDir, {
       count: 1,
       lockDir,
@@ -4158,10 +4445,24 @@ async function collabSync(params) {
           lastServerHeadHash: delta.targetHeadHash,
           lastSeenLocalCommitHash: snapshot.localCommitHash
         });
+        const reportResult = await reportAlignedCheckoutState({
+          api: params.api,
+          appId: binding.currentAppId,
+          repoRoot: lockedRepoRoot,
+          repoFingerprint: binding.repoFingerprint,
+          laneId: binding.laneId,
+          branch,
+          baselineRevisionId: delta.targetRevisionId ?? null,
+          serverRevisionId: delta.targetRevisionId ?? null,
+          localHeadHash: snapshot.localCommitHash,
+          serverHeadCommitId: delta.targetHeadCommitId,
+          serverHeadHash: delta.targetHeadHash,
+          source: "sync_apply"
+        });
         return {
           ...previewResult,
           localCommitHash: snapshot.localCommitHash,
-          ...warnings.length > 0 ? { warnings } : {}
+          ...[...warnings, ...reportResult.warnings].length > 0 ? { warnings: [...warnings, ...reportResult.warnings] } : {}
         };
       }
     );
@@ -4218,13 +4519,56 @@ async function collabSync(params) {
         lastServerHeadHash: delta.targetHeadHash,
         lastSeenLocalCommitHash: snapshot.localCommitHash
       });
+      const reportResult = await reportAlignedCheckoutState({
+        api: params.api,
+        appId: binding.currentAppId,
+        repoRoot: lockedRepoRoot,
+        repoFingerprint: binding.repoFingerprint,
+        laneId: binding.laneId,
+        branch,
+        baselineRevisionId: delta.targetRevisionId ?? null,
+        serverRevisionId: delta.targetRevisionId ?? null,
+        localHeadHash: snapshot.localCommitHash,
+        serverHeadCommitId: delta.targetHeadCommitId,
+        serverHeadHash: delta.targetHeadHash,
+        source: "sync_apply"
+      });
+      const eventResult = await recordLocalAlignmentEvent({
+        api: params.api,
+        appId: binding.currentAppId,
+        eventKind: "sync_local",
+        branch,
+        collabLaneId: binding.laneId,
+        baseRevisionId: baselineServerRevisionId,
+        targetRevisionId: delta.targetRevisionId ?? null,
+        resultRevisionId: delta.targetRevisionId ?? null,
+        baseHeadHash: baselineServerHeadHash,
+        targetHeadCommitId: delta.targetHeadCommitId,
+        targetHeadHash: delta.targetHeadHash,
+        resultHeadHash: delta.targetHeadHash,
+        changedFilesCount: delta.stats.changedFilesCount,
+        insertions: delta.stats.insertions,
+        deletions: delta.stats.deletions,
+        localCommitCount: 0,
+        summary: "Synced local checkout with Remix.",
+        idempotencyKey: buildDeterministicIdempotencyKey({
+          kind: "collab_sync_local_alignment_v1",
+          appId: binding.currentAppId,
+          laneId: binding.laneId,
+          baseRevisionId: baselineServerRevisionId,
+          targetRevisionId: delta.targetRevisionId ?? null,
+          baseHeadHash: baselineServerHeadHash,
+          targetHeadHash: delta.targetHeadHash,
+          diffSha256: delta.diffSha256
+        })
+      });
       return {
         ...previewResult,
         status: "delta_ready",
         localCommitHash: snapshot.localCommitHash,
         applied: true,
         dryRun: false,
-        ...warnings.length > 0 ? { warnings } : {}
+        ...[...warnings, ...reportResult.warnings, ...eventResult.warnings].length > 0 ? { warnings: [...warnings, ...reportResult.warnings, ...eventResult.warnings] } : {}
       };
     }
   );
@@ -4322,38 +4666,38 @@ async function collabApprove(params) {
 }
 
 // src/application/collab/checkoutWorkspace.ts
-import fs6 from "fs/promises";
+import fs7 from "fs/promises";
 import os4 from "os";
-import path7 from "path";
+import path8 from "path";
 async function pathExists(targetPath) {
   try {
-    await fs6.access(targetPath);
+    await fs7.access(targetPath);
     return true;
   } catch {
     return false;
   }
 }
 async function statIsDirectory(targetPath) {
-  const stats = await fs6.stat(targetPath).catch(() => null);
+  const stats = await fs7.stat(targetPath).catch(() => null);
   return Boolean(stats?.isDirectory());
 }
 async function findContainingGitRoot(startPath) {
-  let current = path7.resolve(startPath);
+  let current = path8.resolve(startPath);
   while (true) {
-    if (await pathExists(path7.join(current, ".git"))) return current;
-    const parent = path7.dirname(current);
+    if (await pathExists(path8.join(current, ".git"))) return current;
+    const parent = path8.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
 }
 function isSubpath(parentPath, candidatePath) {
-  const relative = path7.relative(parentPath, candidatePath);
-  return relative === "" || !relative.startsWith("..") && !path7.isAbsolute(relative);
+  const relative = path8.relative(parentPath, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path8.isAbsolute(relative);
 }
 async function resolveCheckoutDestination(params) {
   if (params.outputDir?.trim()) {
-    const preferredRepoRoot = path7.resolve(params.outputDir.trim());
-    const parentDir2 = path7.dirname(preferredRepoRoot);
+    const preferredRepoRoot = path8.resolve(params.outputDir.trim());
+    const parentDir2 = path8.dirname(preferredRepoRoot);
     if (!await statIsDirectory(parentDir2)) {
       throw new RemixError("Remix output parent directory does not exist.", {
         exitCode: 2,
@@ -4366,7 +4710,7 @@ async function resolveCheckoutDestination(params) {
       explicitOutputDir: true
     };
   }
-  const parentDir = path7.resolve(params.cwd);
+  const parentDir = path8.resolve(params.cwd);
   if (!await statIsDirectory(parentDir)) {
     throw new RemixError("Remix output parent directory does not exist.", {
       exitCode: 2,
@@ -4374,7 +4718,7 @@ async function resolveCheckoutDestination(params) {
     });
   }
   return {
-    preferredRepoRoot: path7.join(parentDir, params.defaultDirName),
+    preferredRepoRoot: path8.join(parentDir, params.defaultDirName),
     parentDir,
     explicitOutputDir: false
   };
@@ -4408,12 +4752,21 @@ async function materializeAppCheckout(params) {
     explicitOutputDir: destination.explicitOutputDir
   });
   const repoRoot = destination.explicitOutputDir ? await reserveDirectory(destination.preferredRepoRoot) : await reserveAvailableDirPath(destination.preferredRepoRoot);
-  const bundleTempDir = await fs6.mkdtemp(path7.join(os4.tmpdir(), "remix-checkout-"));
-  const bundlePath = path7.join(bundleTempDir, "repository.bundle");
+  const bundleTempDir = await fs7.mkdtemp(path8.join(os4.tmpdir(), "remix-checkout-"));
+  const bundlePath = path8.join(bundleTempDir, "repository.bundle");
+  const phase = (next) => {
+    try {
+      params.onPhase?.(next);
+    } catch {
+    }
+  };
   try {
+    phase("downloading");
     const bundle = await params.api.downloadAppBundle(params.appId);
-    await fs6.writeFile(bundlePath, bundle.data);
+    phase("unpacking");
+    await fs7.writeFile(bundlePath, bundle.data);
     await cloneGitBundleToDirectory(bundlePath, repoRoot);
+    phase("finalizing");
     if (params.expectedBranchName?.trim()) {
       await checkoutLocalBranch(repoRoot, params.expectedBranchName.trim());
     }
@@ -4422,11 +4775,11 @@ async function materializeAppCheckout(params) {
     }
     await ensureGitInfoExcludeEntries(repoRoot, [".remix/"]);
   } catch (err) {
-    await fs6.rm(repoRoot, { recursive: true, force: true }).catch(() => {
+    await fs7.rm(repoRoot, { recursive: true, force: true }).catch(() => {
     });
     throw err;
   } finally {
-    await fs6.rm(bundleTempDir, { recursive: true, force: true });
+    await fs7.rm(bundleTempDir, { recursive: true, force: true });
   }
   const branchName = await getCurrentBranch(repoRoot) ?? params.expectedBranchName?.trim() ?? null;
   const remoteUrl = normalizeGitRemote(params.expectedRemoteUrl ?? await getRemoteOriginUrl(repoRoot));
@@ -4465,7 +4818,8 @@ async function collabCheckout(params) {
     defaultDirName: sanitizeCheckoutDirName(String(app.name || app.id)),
     expectedBranchName: authoritativeBranchName,
     expectedRemoteUrl: authoritativeRemoteUrl,
-    expectedDefaultBranch: authoritativeDefaultBranch
+    expectedDefaultBranch: authoritativeDefaultBranch,
+    onPhase: params.onPhase
   });
   const upstreamAppId = String(app.forkedFromAppId ?? app.id);
   const laneId = typeof collab?.laneId === "string" ? collab.laneId : null;
@@ -4704,16 +5058,16 @@ async function collabUpdateMemberRole(params) {
 }
 
 // src/application/collab/collabInit.ts
-import fs11 from "fs/promises";
-import path10 from "path";
+import fs12 from "fs/promises";
+import path11 from "path";
 
 // src/shared/hash.ts
 import crypto from "crypto";
-import fs7 from "fs";
+import fs8 from "fs";
 async function sha256FileHex(filePath) {
   const hash = crypto.createHash("sha256");
   await new Promise((resolve, reject) => {
-    const stream = fs7.createReadStream(filePath);
+    const stream = fs8.createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
     stream.on("end", () => resolve());
@@ -5024,11 +5378,11 @@ function branchBindingFromLane(lane, mode, fallback) {
 }
 
 // src/application/collab/collabInitAsync.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 
 // src/infrastructure/collab/drainerLog.ts
-import fs8 from "fs/promises";
-import path8 from "path";
+import fs9 from "fs/promises";
+import path9 from "path";
 async function logDrainerEvent(jobId, event, fields = {}) {
   const entry = {
     ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -5037,8 +5391,8 @@ async function logDrainerEvent(jobId, event, fields = {}) {
     ...fields
   };
   try {
-    await fs8.mkdir(getLogsRoot(), { recursive: true });
-    await fs8.appendFile(getDrainerLogPath(), `${JSON.stringify(entry)}
+    await fs9.mkdir(getLogsRoot(), { recursive: true });
+    await fs9.appendFile(getDrainerLogPath(), `${JSON.stringify(entry)}
 `, "utf8");
   } catch {
   }
@@ -5118,7 +5472,7 @@ async function clearFailedAsyncInitJobs(params) {
 }
 async function enqueueInitPostJob(params) {
   const job = await enqueueAsyncJob({
-    id: randomUUID4(),
+    id: randomUUID5(),
     kind: "init_post",
     status: "queued",
     repoRoot: params.repoRoot,
@@ -5143,19 +5497,19 @@ async function enqueueInitPostJob(params) {
 }
 
 // src/application/collab/collabInitImport.ts
-import fs10 from "fs/promises";
-import path9 from "path";
+import fs11 from "fs/promises";
+import path10 from "path";
 
 // src/shared/upload.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import { PassThrough } from "stream";
 async function uploadPresigned(params) {
-  const stats = await fs9.promises.stat(params.filePath).catch(() => null);
+  const stats = await fs10.promises.stat(params.filePath).catch(() => null);
   if (!stats || !stats.isFile()) {
     throw new RemixError("Upload file not found.", { exitCode: 2 });
   }
   const totalBytes = stats.size;
-  const fileStream = fs9.createReadStream(params.filePath);
+  const fileStream = fs10.createReadStream(params.filePath);
   const pass = new PassThrough();
   let sentBytes = 0;
   fileStream.on("data", (chunk) => {
@@ -5182,8 +5536,8 @@ ${text}`.trim() || null
 
 // src/application/collab/collabInitImport.ts
 async function uploadInitBundle(params) {
-  const bundleName = params.bundleName ?? path9.basename(params.bundlePath);
-  const bundleSize = (await fs10.stat(params.bundlePath)).size;
+  const bundleName = params.bundleName ?? path10.basename(params.bundlePath);
+  const bundleSize = (await fs11.stat(params.bundlePath)).size;
   const presignResp = await params.api.presignImportUploadFirstParty({
     file: {
       name: bundleName,
@@ -5352,7 +5706,7 @@ async function collabInit(params) {
           appId: boundCurrentAppId2,
           dashboardUrl: buildDashboardAppUrl(boundCurrentAppId2),
           upstreamAppId: boundUpstreamAppId2,
-          bindingPath: path10.join(repoRoot, ".remix", "config.json"),
+          bindingPath: path11.join(repoRoot, ".remix", "config.json"),
           repoRoot,
           repoFingerprint,
           bindingMode: defaultBranch && branchName !== defaultBranch ? "lane" : "explicit_root",
@@ -5623,7 +5977,7 @@ async function collabInit(params) {
           repoRoot,
           "repository.bundle"
         );
-        const tmpBundleDir = path10.dirname(bundleFilePath);
+        const tmpBundleDir = path11.dirname(bundleFilePath);
         try {
           const bundleSha2 = await sha256FileHex(bundleFilePath);
           const uploadId2 = await uploadInitBundle({
@@ -5635,7 +5989,7 @@ async function collabInit(params) {
           const imported2 = await importUploadedInitBundle({
             api: params.api,
             uploadId: uploadId2,
-            appName: params.appName?.trim() || path10.basename(repoRoot),
+            appName: params.appName?.trim() || path11.basename(repoRoot),
             profile: params.profile ?? void 0,
             branch: defaultBranch && branchName && branchName !== defaultBranch ? defaultBranch : currentBranch ?? void 0,
             remoteUrl,
@@ -5794,7 +6148,7 @@ async function collabInit(params) {
             ...warnings.length > 0 ? { warnings } : {}
           };
         } finally {
-          await fs11.rm(tmpBundleDir, { recursive: true, force: true }).catch(() => void 0);
+          await fs12.rm(tmpBundleDir, { recursive: true, force: true }).catch(() => void 0);
         }
       }
       const { bundlePath, headCommitHash } = await createGitBundle(repoRoot, "repository.bundle");
@@ -5808,7 +6162,7 @@ async function collabInit(params) {
       const imported = await importUploadedInitBundle({
         api: params.api,
         uploadId,
-        appName: params.appName?.trim() || path10.basename(repoRoot),
+        appName: params.appName?.trim() || path11.basename(repoRoot),
         path: params.path?.trim() || void 0,
         profile: params.profile ?? void 0,
         branch: defaultBranch && branchName && branchName !== defaultBranch ? defaultBranch : currentBranch ?? void 0,
@@ -6017,9 +6371,9 @@ async function collabList(params) {
 }
 
 // src/application/collab/collabReconcile.ts
-import fs12 from "fs/promises";
+import fs13 from "fs/promises";
 import os5 from "os";
-import path11 from "path";
+import path12 from "path";
 import { execa as execa2 } from "execa";
 
 // src/application/collab/pendingFinalize.ts
@@ -6187,12 +6541,12 @@ async function reconcileBothChanged(params) {
   const replay = await pollChangeStepReplay(params.api, binding.currentAppId, String(replayStart.id));
   const replayDiffResp = await params.api.getChangeStepReplayDiff(binding.currentAppId, replay.id);
   const replayDiff = unwrapResponseObject(replayDiffResp, "change step replay diff");
-  const tempRoot = await fs12.mkdtemp(path11.join(os5.tmpdir(), "remix-reconcile-"));
+  const tempRoot = await fs13.mkdtemp(path12.join(os5.tmpdir(), "remix-reconcile-"));
   let serverHeadSnapshot = null;
   let mergedSnapshot = null;
   try {
-    const tempRepoRoot = path11.join(tempRoot, "repo");
-    await fs12.mkdir(tempRepoRoot, { recursive: true });
+    const tempRepoRoot = path12.join(tempRoot, "repo");
+    await fs13.mkdir(tempRepoRoot, { recursive: true });
     await execa2("git", ["init"], { cwd: tempRepoRoot, stderr: "ignore" });
     await materializeLocalSnapshot(baseline.lastSnapshotId, tempRepoRoot);
     if (shouldApplyServerDeltaBeforeReplay({ deltaStatus: delta.status, diff: delta.diff })) {
@@ -6214,7 +6568,7 @@ async function reconcileBothChanged(params) {
       branchName: binding.branchName
     });
   } finally {
-    await fs12.rm(tempRoot, { recursive: true, force: true }).catch(() => void 0);
+    await fs13.rm(tempRoot, { recursive: true, force: true }).catch(() => void 0);
   }
   if (!serverHeadSnapshot || !mergedSnapshot) {
     throw new RemixError("Failed to materialize the reconciled local workspace.", { exitCode: 1 });
@@ -6256,15 +6610,58 @@ async function reconcileBothChanged(params) {
         lastServerHeadHash: appHead.headCommitHash,
         lastSeenLocalCommitHash: restoredSnapshot.localCommitHash
       });
+      const reportResult = await reportAlignedCheckoutState({
+        api: params.api,
+        appId: binding.currentAppId,
+        repoRoot: lockedRepoRoot,
+        repoFingerprint: binding.repoFingerprint,
+        laneId: binding.laneId,
+        branch,
+        baselineRevisionId: appHead.headRevisionId ?? null,
+        serverRevisionId: appHead.headRevisionId ?? null,
+        localHeadHash: restoredSnapshot.localCommitHash,
+        serverHeadCommitId: appHead.headCommitId,
+        serverHeadHash: appHead.headCommitHash,
+        source: "reconcile_apply"
+      });
+      const eventResult = await recordLocalAlignmentEvent({
+        api: params.api,
+        appId: binding.currentAppId,
+        eventKind: "reconcile_local",
+        branch,
+        collabLaneId: binding.laneId,
+        baseRevisionId: baseline.lastServerRevisionId,
+        targetRevisionId: appHead.headRevisionId ?? null,
+        resultRevisionId: appHead.headRevisionId ?? null,
+        baseHeadHash: baseline.lastServerHeadHash,
+        targetHeadCommitId: appHead.headCommitId,
+        targetHeadHash: appHead.headCommitHash,
+        resultHeadHash: appHead.headCommitHash,
+        changedFilesCount: diffResult.stats.changedFilesCount,
+        insertions: diffResult.stats.insertions,
+        deletions: diffResult.stats.deletions,
+        localCommitCount: 0,
+        summary: "Reconciled local checkout with Remix.",
+        idempotencyKey: buildDeterministicIdempotencyKey({
+          kind: "collab_reconcile_local_alignment_v1",
+          appId: binding.currentAppId,
+          laneId: binding.laneId,
+          baseRevisionId: baseline.lastServerRevisionId,
+          targetRevisionId: appHead.headRevisionId ?? null,
+          baseHeadHash: baseline.lastServerHeadHash,
+          targetHeadHash: appHead.headCommitHash,
+          localDiffSha256: diffResult.diffSha256,
+          replayId: replay.id
+        })
+      });
+      const mergedWarnings = Array.from(/* @__PURE__ */ new Set([...delta.warnings, ...warnings, ...reportResult.warnings, ...eventResult.warnings]));
       return {
         ...preview,
         status: "reconciled",
         localHeadCommitHash: restoredSnapshot.localCommitHash,
         applied: workspaceChanged,
         dryRun: false,
-        ...warnings.length > 0 ? {
-          warnings: Array.from(/* @__PURE__ */ new Set([...delta.warnings, ...warnings]))
-        } : {}
+        ...mergedWarnings.length > 0 ? { warnings: mergedWarnings } : {}
       };
     }
   );
@@ -6355,7 +6752,8 @@ async function collabRemix(params) {
     defaultDirName: sanitizeCheckoutDirName(String(params.name?.trim() || app.name || app.id)),
     expectedBranchName: authoritativeBranchName,
     expectedRemoteUrl: authoritativeRemoteUrl,
-    expectedDefaultBranch: authoritativeDefaultBranch
+    expectedDefaultBranch: authoritativeDefaultBranch,
+    onPhase: params.onPhase
   });
   const laneId = typeof collab?.laneId === "string" ? collab.laneId : null;
   const repoFingerprint = typeof source?.repoFingerprint === "string" ? source.repoFingerprint : checkout.repoFingerprint;
@@ -6842,6 +7240,8 @@ async function collabStatus(params) {
   if ((status.remote.incomingOpenMergeRequestCount ?? 0) > 0 && status.recommendedAction === "no_action") {
     status.recommendedAction = "review_queue";
   }
+  const reportResult = await reportCheckoutStateFromStatus({ api: params.api, status, source: "status" });
+  for (const warning of reportResult.warnings) addWarning(status, warning);
   return status;
 }
 
@@ -6945,11 +7345,11 @@ async function collabView(params) {
 }
 
 // src/application/collab/collabAsyncProcessing.ts
-import fs13 from "fs/promises";
-import path12 from "path";
+import fs14 from "fs/promises";
+import path13 from "path";
 
 // src/application/collab/collabDependencies.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 function isFullLocalStateRepository(value) {
   return typeof value.bindings?.getPath === "function" && typeof value.bindings.read === "function" && typeof value.bindings.readState === "function" && typeof value.bindings.write === "function" && typeof value.bindings.writeSnapshot === "function" && typeof value.baselines?.read === "function" && typeof value.baselines.write === "function" && typeof value.baselines.clear === "function" && typeof value.snapshots?.inspect === "function" && typeof value.snapshots.capture === "function" && typeof value.snapshots.read === "function" && typeof value.snapshots.materialize === "function" && typeof value.snapshots.restoreToWorktree === "function" && typeof value.snapshots.diff === "function" && typeof value.asyncJobs?.enqueue === "function" && typeof value.asyncJobs.read === "function" && typeof value.asyncJobs.list === "function" && typeof value.asyncJobs.listForRepo === "function" && typeof value.asyncJobs.findPending === "function" && typeof value.asyncJobs.findFailed === "function" && typeof value.asyncJobs.update === "function" && typeof value.asyncJobs.delete === "function" && typeof value.asyncJobs.claim === "function" && typeof value.asyncJobs.summarize === "function" && typeof value.asyncJobs.pruneTerminal === "function" && typeof value.asyncJobs.getBundleFilePath === "function" && typeof value.asyncJobs.await === "function" && typeof value.finalizeJobs?.enqueue === "function" && typeof value.finalizeJobs.read === "function" && typeof value.finalizeJobs.list === "function" && typeof value.finalizeJobs.update === "function" && typeof value.finalizeJobs.claim === "function" && typeof value.finalizeJobs.remove === "function" && typeof value.finalizeJobs.forget === "function" && typeof value.finalizeJobs.requeue === "function" && typeof value.finalizeJobs.heartbeatLock === "function" && typeof value.finalizeJobs.cleanStaleLocks === "function" && typeof value.finalizeJobs.prune === "function" && typeof value.finalizeJobs.summarize === "function";
 }
@@ -6964,7 +7364,7 @@ function createCollabDependencies(overrides = {}) {
   const localState3 = overrides.localState ? isFullLocalStateRepository(overrides.localState) ? overrides.localState : createLocalStateRepository(overrides.localState) : createLocalStateRepository();
   return {
     clock: { ...defaultClock, ...overrides.clock },
-    ids: { randomUUID: randomUUID5, ...overrides.ids },
+    ids: { randomUUID: randomUUID6, ...overrides.ids },
     timers: { ...defaultTimers, ...overrides.timers },
     git: overrides.git ?? createSystemGitAdapter(),
     localState: localState3,
@@ -7086,10 +7486,10 @@ async function processInitJob(job, api) {
   try {
     await localState2.asyncJobs.update(job.id, { status: "submitting", error: null });
     await logDrainerWorkflowEvent(job.id, "claimed", { kind: "init" });
-    const bundleStat = await fs13.stat(job.payload.bundlePath);
+    const bundleStat = await fs14.stat(job.payload.bundlePath);
     const presignResp = await api.presignImportUploadFirstParty({
       file: {
-        name: path12.basename(job.payload.bundlePath),
+        name: path13.basename(job.payload.bundlePath),
         mimeType: "application/x-git-bundle",
         size: bundleStat.size,
         checksumSha256: job.payload.bundleSha256
@@ -7106,7 +7506,7 @@ async function processInitJob(job, api) {
     await localState2.asyncJobs.update(job.id, { status: "server_processing" });
     const importResp = await api.importFromUploadFirstParty({
       uploadId: String(presign.uploadId),
-      appName: job.payload.appName?.trim() || path12.basename(job.repoRoot),
+      appName: job.payload.appName?.trim() || path13.basename(job.repoRoot),
       platform: "generic",
       isPublic: false,
       branch: job.payload.defaultBranch && job.branchName && job.branchName !== job.payload.defaultBranch ? job.payload.defaultBranch : job.branchName ?? void 0,
@@ -7312,7 +7712,7 @@ async function processInitPostJob(job, api) {
     if (outcome.status === "failed") {
       const bindingPath = localState2.bindings.getPath(job.repoRoot);
       try {
-        await fs13.unlink(bindingPath);
+        await fs14.unlink(bindingPath);
         await logDrainerWorkflowEvent(job.id, "binding_cleared", {
           kind: "init_post",
           appId: job.payload.appId,
@@ -7364,9 +7764,9 @@ async function collabInitPostProcess(jobId, opts) {
 }
 async function acquireDrainerPidLock() {
   const pidPath = getDrainerPidPath();
-  await fs13.mkdir(path12.dirname(pidPath), { recursive: true });
+  await fs14.mkdir(path13.dirname(pidPath), { recursive: true });
   try {
-    const existing = await fs13.readFile(pidPath, "utf8").catch(() => "");
+    const existing = await fs14.readFile(pidPath, "utf8").catch(() => "");
     const existingPid = parseInt(existing.trim(), 10);
     if (Number.isFinite(existingPid) && existingPid > 0 && existingPid !== process.pid) {
       try {
@@ -7376,13 +7776,13 @@ async function acquireDrainerPidLock() {
         if (error?.code !== "ESRCH") return null;
       }
     }
-    await fs13.writeFile(pidPath, String(process.pid), "utf8");
+    await fs14.writeFile(pidPath, String(process.pid), "utf8");
     return {
       release: async () => {
         try {
-          const current = (await fs13.readFile(pidPath, "utf8")).trim();
+          const current = (await fs14.readFile(pidPath, "utf8")).trim();
           if (current === String(process.pid)) {
-            await fs13.unlink(pidPath).catch(() => void 0);
+            await fs14.unlink(pidPath).catch(() => void 0);
           }
         } catch {
         }

package/dist/{contracts-BqC3Lj7W.d.ts → contracts-DTeSJnoC.d.ts}

@@ -732,6 +732,49 @@ type CollabApiClient = {
         defaultBranch?: string;
         dryRun?: boolean;
     }): Promise<unknown>;
+    reportLocalCheckoutState(appId: string, payload: {
+        checkoutId: string;
+        collabLaneId?: string;
+        branch?: string;
+        repoFingerprint?: string;
+        localState?: string;
+        recommendedAction: "pull" | "reconcile" | "await_finalize" | "record" | "no_action";
+        materializationStatus?: string;
+        alignmentRequired?: string;
+        baselineRevisionId?: string | null;
+        localRevisionId?: string | null;
+        serverRevisionId?: string | null;
+        localHeadHash?: string;
+        serverHeadCommitId?: string | null;
+        serverHeadHash?: string;
+        hasLocalChanges?: boolean;
+        hasUnrecordedChanges?: boolean;
+        pendingFinalizeCount?: number;
+        lastSeenAt?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<unknown>;
+    getLatestLocalCheckoutState(appId: string): Promise<unknown>;
+    recordLocalAlignmentEvent(appId: string, payload: {
+        eventKind: "sync_local" | "reconcile_local";
+        branch?: string;
+        collabLaneId?: string;
+        baseRevisionId?: string | null;
+        targetRevisionId?: string | null;
+        resultRevisionId?: string | null;
+        baseHeadCommitId?: string | null;
+        baseHeadHash?: string;
+        targetHeadCommitId?: string | null;
+        targetHeadHash?: string;
+        resultHeadCommitId?: string | null;
+        resultHeadHash?: string;
+        changedFilesCount?: number;
+        insertions?: number;
+        deletions?: number;
+        localCommitCount?: number;
+        summary?: string;
+        idempotencyKey?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<unknown>;
 };
 
 export type { AppProfileInput as A, ModelCall as B, CollabApiClient as C, OrganizationMemberRole as D, ProjectMemberRole as E, SyncLocalResponse as F, SyncUpstreamResponse as G, TurnUsageCaptureSource as H, InvitationScopeType as I, JsonObject as J, TurnUsageConfidence as K, TurnUsagePreviousPatch as L, MergeRequestQueue as M, OrganizationMember as O, ProjectMember as P, ReconcilePreflightResponse as R, ServerToolUsage as S, TurnUsage as T, TurnUsagePayload as a, CollabFinalizeTurnResult as b, CollabRecordingPreflight as c, CollabApproveMode as d, CollabApprovalStrategy as e, CollabApproveResult as f, MergeRequest as g, CollabMember as h, AppDeltaResponse as i, CollabStatus as j, MergeRequestReview as k, AppHeadResponse as l, AppMember as m, AppMemberRole as n, AppReconcileResponse as o, CollabFinalizeTurnAutoSync as p, CollabFinalizeTurnMode as q, CollabPendingFinalizeState as r, CollabPendingFinalizeSummary as s, CollabRecordingPreflightStatus as t, CollabRepoStateKind as u, CollabStatusBlockedReason as v, CollabStatusRecommendedAction as w, CollabTurn as x, MembershipScopeType as y, MergeRequestStatus as z };

package/dist/history.d.ts

@@ -1,4 +1,4 @@
-import { T as TurnUsage } from './contracts-BqC3Lj7W.js';
+import { T as TurnUsage } from './contracts-DTeSJnoC.js';
 
 type TranscriptEvent = Record<string, unknown>;
 type ReadTranscriptResult = {

package/dist/index.d.ts

@@ -4,4 +4,4 @@ export { S as SessionStore, a as StoredSession, W as WithRefreshLock, c as creat
 export { createDefaultRefreshLock, createLocalSessionStore, createSupabaseAuthHelpers, defaultSessionFilePath, isInvalidGrantError, isNetworkError } from './auth.js';
 export { AgentMemoryItem, AgentMemoryKind, AgentMemorySearchItem, AgentMemorySearchResponse, AgentMemorySummary, AgentMemoryTimelineResponse, ApiClient, AppContext, AppContextAccessPath, AppPreviewExpectedKind, AppPreviewProcessStatus, AppPreviewQuery, AppPreviewResponse, AppReconcileResponse, AppSandboxCommandRun, AppShareLinkSummary, Bundle, BundlePlatform, BundleStatus, ChangeStepDiffResponse, CreateAppShareLinkPayload, DetectProjectRuntimeTargetsPayload, ImportProjectRuntimeEnvPayload, InitiateBundleRequest, InvitationRecord, MergeRequest, MergeRequestReview, MergeRequestStatus, ProjectRuntimeEnvMetadata, ProjectRuntimeEnvScope, ProjectRuntimeTargetMetadata, ProjectRuntimeTargetScope, ProjectTrigger, ProjectTriggerPayload, ProjectTriggerScope, ProjectTriggerStep, ProjectTriggerStepPayload, ReconcilePreflightResponse, ResolveProjectRuntimeEnvForLocalPullResponse, RunAppRuntimeTargetPayload, RunAppSandboxCommandPayload, RunAppTriggerEventPayload, RunAppTriggerPayload, RuntimeCommandKind, RuntimeTargetKind, SetProjectRuntimeEnvPayload, SetProjectRuntimeTargetPayload, SyncLocalResponse, SyncUpstreamResponse, TriggerEventMetadata, TriggerEventSource, TriggerIntegrationStatus, TriggerMode, TriggerRun, TriggerStepRun, TriggerStepType, UpdateProjectTriggerPayload, createApiClient } from './api.js';
 import 'zod';
-import './contracts-BqC3Lj7W.js';
+import './contracts-DTeSJnoC.js';

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   createApiClient
-} from "./chunk-MNVBXTSV.js";
+} from "./chunk-QIESQM7X.js";
 import {
   createDefaultRefreshLock,
   createLocalSessionStore,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remixhq/core",
-  "version": "0.1.36",
+  "version": "0.1.38",
   "description": "Remix core library",
   "homepage": "https://github.com/RemixDotOne/remix-core",
   "license": "MIT",