@remixhq/core 0.1.33 → 0.1.35

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-WCYiMqwB.js';
+import { T as TurnUsage } from './contracts-BqC3Lj7W.js';
 import 'zod';
 
 type HistoryImportProvider = "claude_code" | "cursor";

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-WCYiMqwB.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-WCYiMqwB.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-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 { B as BranchBindingMode } from './binding-WiIRI2fl.js';
 
 declare function collabFinalizeTurn(params: {

package/dist/collab.js

@@ -509,6 +509,13 @@ import path3 from "path";
 function getBaselinePath(params) {
   return path3.join(getBaselinesRoot(), `${buildLaneStateKey(params)}.json`);
 }
+function normalizeNullableString(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || null;
+}
+function isSameBaselineIdentity(left, right) {
+  return left.repoRoot === right.repoRoot && (left.repoFingerprint ?? null) === (right.repoFingerprint ?? null) && (left.laneId ?? null) === (right.laneId ?? null) && left.currentAppId === right.currentAppId && (left.branchName ?? null) === (right.branchName ?? null);
+}
 async function readLocalBaseline(params) {
   try {
     const raw = await fs2.readFile(getBaselinePath(params), "utf8");
@@ -558,6 +565,105 @@ async function writeLocalBaseline(baseline) {
   await writeJsonAtomic(getBaselinePath(baseline), normalized);
   return normalized;
 }
+async function readAllLocalBaselines() {
+  let entries;
+  try {
+    entries = await fs2.readdir(getBaselinesRoot());
+  } catch (error) {
+    if (error?.code === "ENOENT") return [];
+    throw error;
+  }
+  const baselines = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) continue;
+    try {
+      const raw = await fs2.readFile(path3.join(getBaselinesRoot(), entry), "utf8");
+      const parsed = JSON.parse(raw);
+      if (!parsed || typeof parsed !== "object") continue;
+      if (![1, 2].includes(Number(parsed.schemaVersion)) || typeof parsed.key !== "string" || typeof parsed.repoRoot !== "string") {
+        continue;
+      }
+      baselines.push({
+        schemaVersion: Number(parsed.schemaVersion) === 2 ? 2 : 1,
+        key: parsed.key,
+        repoRoot: parsed.repoRoot,
+        repoFingerprint: parsed.repoFingerprint ?? null,
+        laneId: parsed.laneId ?? null,
+        currentAppId: String(parsed.currentAppId ?? ""),
+        branchName: parsed.branchName ?? null,
+        lastSnapshotId: parsed.lastSnapshotId ?? null,
+        lastSnapshotHash: parsed.lastSnapshotHash ?? null,
+        lastServerRevisionId: parsed.lastServerRevisionId ?? null,
+        lastServerTreeHash: parsed.lastServerTreeHash ?? null,
+        lastServerHeadHash: parsed.lastServerHeadHash ?? null,
+        lastSeenLocalCommitHash: parsed.lastSeenLocalCommitHash ?? null,
+        updatedAt: String(parsed.updatedAt ?? "")
+      });
+    } catch {
+      continue;
+    }
+  }
+  return baselines;
+}
+async function migrateLocalBaselineForLaneChange(params) {
+  if ((params.fromLaneId ?? null) === (params.toLaneId ?? null)) {
+    return { status: "same_lane" };
+  }
+  const target = await readLocalBaseline({
+    repoRoot: params.repoRoot,
+    repoFingerprint: params.repoFingerprint,
+    laneId: params.toLaneId
+  });
+  if (target) {
+    return { status: "target_exists" };
+  }
+  const source = await readLocalBaseline({
+    repoRoot: params.repoRoot,
+    repoFingerprint: params.repoFingerprint,
+    laneId: params.fromLaneId
+  });
+  if (!source) {
+    return { status: "source_missing" };
+  }
+  const expectedSource = {
+    repoRoot: params.repoRoot,
+    repoFingerprint: params.repoFingerprint,
+    laneId: params.fromLaneId,
+    currentAppId: params.currentAppId,
+    branchName: params.branchName
+  };
+  const actualSource = {
+    repoRoot: source.repoRoot,
+    repoFingerprint: source.repoFingerprint,
+    laneId: source.laneId,
+    currentAppId: source.currentAppId,
+    branchName: source.branchName
+  };
+  if (!isSameBaselineIdentity(actualSource, expectedSource)) {
+    return { status: "source_missing" };
+  }
+  const baseline = await writeLocalBaseline({
+    ...source,
+    laneId: params.toLaneId
+  });
+  return { status: "migrated", baseline };
+}
+async function findCompatibleLocalBaseline(params) {
+  const targetKey = buildLaneStateKey(params);
+  const branchName = normalizeNullableString(params.branchName);
+  const candidates = (await readAllLocalBaselines()).filter((baseline) => {
+    if (baseline.key === targetKey) return false;
+    if (baseline.repoRoot !== params.repoRoot) return false;
+    if ((baseline.repoFingerprint ?? null) !== (params.repoFingerprint ?? null)) return false;
+    if (baseline.currentAppId !== params.currentAppId) return false;
+    return true;
+  });
+  const branchMatches = candidates.filter((baseline) => normalizeNullableString(baseline.branchName) === branchName);
+  const compatible = branchMatches.length > 0 ? branchMatches : candidates.filter((baseline) => normalizeNullableString(baseline.branchName) === null);
+  if (compatible.length === 0) return { status: "none", candidateCount: 0 };
+  if (compatible.length > 1) return { status: "ambiguous", candidateCount: compatible.length };
+  return { status: "found", baseline: compatible[0] };
+}
 async function clearLocalBaseline(params) {
   try {
     await fs2.unlink(getBaselinePath(params));
@@ -1500,6 +1606,7 @@ function resolveLaneLookupProjectId(params) {
   return params.explicitRootProjectId ?? (params.requireRemoteLane ? void 0 : localProjectId ?? params.fallbackProjectId ?? void 0);
 }
 async function persistResolvedLane(repoRoot, binding) {
+  const previousBinding = await readCollabBinding(repoRoot);
   await writeCollabBinding(repoRoot, {
     projectId: binding.projectId,
     currentAppId: binding.currentAppId,
@@ -1512,6 +1619,16 @@ async function persistResolvedLane(repoRoot, binding) {
     branchName: binding.branchName,
     bindingMode: binding.bindingMode
   });
+  if (previousBinding && (previousBinding.laneId ?? null) !== (binding.laneId ?? null)) {
+    await migrateLocalBaselineForLaneChange({
+      repoRoot,
+      repoFingerprint: binding.repoFingerprint,
+      currentAppId: binding.currentAppId,
+      branchName: binding.branchName,
+      fromLaneId: previousBinding.laneId,
+      toLaneId: binding.laneId
+    });
+  }
   return readCollabBinding(repoRoot);
 }
 function buildAmbiguousResolution(params) {
@@ -1911,11 +2028,36 @@ async function collabDetectRepoState(params) {
     return detected;
   }
   try {
-    const baseline = await readLocalBaseline({
+    let baseline = await readLocalBaseline({
       repoFingerprint: binding.repoFingerprint,
       laneId: binding.laneId,
       repoRoot
     });
+    let ambiguousBaselineCandidateCount = null;
+    if (!baseline) {
+      const compatibleBaseline = await findCompatibleLocalBaseline({
+        repoRoot,
+        repoFingerprint: binding.repoFingerprint,
+        laneId: binding.laneId,
+        currentAppId: binding.currentAppId,
+        branchName: binding.branchName
+      });
+      if (compatibleBaseline.status === "found") {
+        baseline = await writeLocalBaseline({
+          ...compatibleBaseline.baseline,
+          repoRoot,
+          repoFingerprint: binding.repoFingerprint,
+          laneId: binding.laneId,
+          currentAppId: binding.currentAppId,
+          branchName: binding.branchName
+        });
+        detected.warnings.push(
+          `Recovered local Remix baseline after lane id changed from ${compatibleBaseline.baseline.laneId ?? "null"} to ${binding.laneId ?? "null"} for app ${binding.currentAppId} on branch ${binding.branchName ?? "(unknown)"}.`
+        );
+      } else if (compatibleBaseline.status === "ambiguous") {
+        ambiguousBaselineCandidateCount = compatibleBaseline.candidateCount;
+      }
+    }
     const hasFullBaseline = Boolean(baseline?.lastSnapshotHash && baseline?.lastServerHeadHash);
     const metadataIdentityPromise = hasFullBaseline ? getAppDeltaCached(params.api, binding.currentAppId, {
       baseHeadHash: baseline.lastServerHeadHash,
@@ -1988,7 +2130,7 @@ async function collabDetectRepoState(params) {
         }
       }
       detected.repoState = "external_local_base_changed";
-      detected.hint = "No local Remix revision baseline exists for this lane yet. Run `remix collab init` or sync this lane to seed the baseline.";
+      detected.hint = ambiguousBaselineCandidateCount !== null ? `No local Remix revision baseline exists for this lane, and multiple compatible local baselines were found (${ambiguousBaselineCandidateCount}). Run \`remix collab status\` or sync this lane to seed an unambiguous baseline.` : "No local Remix revision baseline exists for this lane yet. Run `remix collab init` or sync this lane to seed the baseline.";
       return detected;
     }
     const localHeadMovedSinceBaseline = Boolean(baseline.lastSeenLocalCommitHash) && localCommitHash !== baseline.lastSeenLocalCommitHash;
@@ -3098,11 +3240,174 @@ async function drainPendingFinalizeQueue(params) {
 
 // src/application/collab/collabFinalizeTurn.ts
 var FINALIZE_AWAIT_INIT_POST_TIMEOUT_MS = 6e4;
+var FINALIZE_UNALIGNED_DRAIN_TIMEOUT_MS = 1e4;
 function collectWarnings(value) {
   if (!Array.isArray(value)) return [];
   return value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
 }
+function throwBlockingDetectedStatus(detected) {
+  if (detected.status === "not_bound") {
+    throw new RemixError("Repository is not bound to Remix.", {
+      code: "not_bound",
+      exitCode: 2,
+      hint: detected.hint
+    });
+  }
+  if (detected.status === "branch_binding_missing") {
+    throw new RemixError(detected.hint || "Current branch is not ready for Remix recording.", {
+      code: detected.status,
+      exitCode: 2,
+      hint: detected.hint
+    });
+  }
+  if (detected.status === "family_ambiguous") {
+    throw new RemixError(detected.hint || "Current branch is not ready for Remix recording.", {
+      code: detected.status,
+      exitCode: 2,
+      hint: detected.hint
+    });
+  }
+  if (detected.status === "metadata_conflict" || detected.status === "branch_mismatch") {
+    throw new RemixError("Repository must be realigned before finalizing the turn.", {
+      code: detected.status,
+      exitCode: 2,
+      hint: detected.hint
+    });
+  }
+  if (detected.status === "remote_error") {
+    const message = detected.hint || "Failed to determine the current repo state.";
+    throw new RemixError(message, {
+      code: detected.status,
+      exitCode: 1,
+      hint: detected.hint
+    });
+  }
+}
+function withTimeout(work, timeoutMs, message) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+    timer.unref?.();
+  });
+  return Promise.race([work, timeout]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
+async function drainPendingFinalizeBeforeUnalignedFallback(params) {
+  const summary = await summarizePendingFinalizeJobs({
+    repoRoot: params.repoRoot,
+    repoFingerprint: params.repoFingerprint,
+    currentAppId: params.currentAppId,
+    laneId: params.laneId
+  });
+  if (summary.activeJobCount <= 0) {
+    return { attempted: false, warnings: [] };
+  }
+  const warnings = [];
+  try {
+    await withTimeout(
+      drainPendingFinalizeQueue({ api: params.api }),
+      FINALIZE_UNALIGNED_DRAIN_TIMEOUT_MS,
+      `Timed out waiting ${Math.round(
+        FINALIZE_UNALIGNED_DRAIN_TIMEOUT_MS / 1e3
+      )}s for pending Remix turn recording to advance the local baseline.`
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    warnings.push(`Pending Remix turn recording could not be drained before this turn was captured: ${message}`);
+  } finally {
+    invalidateAppHeadCache(params.currentAppId);
+    invalidateAppDeltaCacheForApp(params.currentAppId);
+  }
+  return { attempted: true, warnings };
+}
 var FINALIZE_QUEUED_WARNING = "Queued only: the local Remix turn was captured, but no remote change step or collab turn exists yet. Drain or await finalize before merge-related flows.";
+var CONVERSATION_ONLY_WARNING = "Recorded conversation only: this turn was not materialized into a change step.";
+function buildConversationOnlyWorkspaceMetadata(params) {
+  const metadata = {
+    branch: params.branchName,
+    repoRoot: params.repoRoot,
+    remoteUrl: params.remoteUrl,
+    defaultBranch: params.defaultBranch,
+    recordingMode: "conversation_only",
+    materializationStatus: params.materializationStatus,
+    alignmentRequired: params.alignmentRequired,
+    baselineSnapshotId: params.baselineSnapshotId,
+    baselineServerRevisionId: params.baselineServerRevisionId,
+    baselineServerHeadHash: params.baselineServerHeadHash,
+    currentServerRevisionId: params.currentServerRevisionId,
+    currentServerHeadHash: params.currentServerHeadHash,
+    currentServerHeadCommitId: params.currentServerHeadCommitId,
+    localCommitHash: params.localCommitHash,
+    repoStateAtCapture: params.repoState,
+    actor: params.actor ?? null
+  };
+  if (params.turnUsage) {
+    metadata.turnUsage = params.turnUsage;
+  }
+  if (typeof params.promptedAt === "string" && params.promptedAt.trim()) {
+    metadata.promptedAt = params.promptedAt.trim();
+  }
+  return metadata;
+}
+async function recordConversationOnlyTurn(params) {
+  const idempotencyKey = params.explicitIdempotencyKey?.trim() || buildDeterministicIdempotencyKey({
+    kind: "collab_finalize_turn_conversation_only_v1",
+    appId: params.binding.currentAppId,
+    laneId: params.binding.laneId,
+    materializationStatus: params.materializationStatus,
+    alignmentRequired: params.alignmentRequired,
+    baselineSnapshotId: params.baselineSnapshotId ?? null,
+    baselineServerRevisionId: params.baselineServerRevisionId ?? null,
+    baselineServerHeadHash: params.baselineServerHeadHash ?? null,
+    currentServerRevisionId: params.currentServerRevisionId ?? null,
+    currentServerHeadHash: params.currentServerHeadHash ?? null,
+    currentServerHeadCommitId: params.currentServerHeadCommitId ?? null,
+    localCommitHash: params.localCommitHash ?? null,
+    repoState: params.repoState,
+    prompt: params.prompt,
+    assistantResponse: params.assistantResponse
+  });
+  const collabTurnResp = await params.api.createCollabTurn(params.binding.currentAppId, {
+    threadId: params.binding.threadId ?? void 0,
+    collabLaneId: params.binding.laneId ?? void 0,
+    prompt: params.prompt,
+    assistantResponse: params.assistantResponse,
+    actor: params.actor,
+    workspaceMetadata: buildConversationOnlyWorkspaceMetadata({
+      repoRoot: params.repoRoot,
+      branchName: params.binding.branchName,
+      remoteUrl: params.binding.remoteUrl,
+      defaultBranch: params.binding.defaultBranch,
+      baselineSnapshotId: params.baselineSnapshotId ?? null,
+      baselineServerRevisionId: params.baselineServerRevisionId ?? null,
+      baselineServerHeadHash: params.baselineServerHeadHash ?? null,
+      currentServerRevisionId: params.currentServerRevisionId ?? null,
+      currentServerHeadHash: params.currentServerHeadHash ?? null,
+      currentServerHeadCommitId: params.currentServerHeadCommitId ?? null,
+      localCommitHash: params.localCommitHash ?? null,
+      repoState: params.repoState,
+      materializationStatus: params.materializationStatus,
+      alignmentRequired: params.alignmentRequired,
+      actor: params.actor ?? null,
+      turnUsage: params.turnUsage ?? null,
+      promptedAt: params.promptedAt
+    }),
+    idempotencyKey
+  });
+  const collabTurn = unwrapResponseObject(collabTurnResp, "collab turn");
+  return {
+    mode: "conversation_only",
+    idempotencyKey,
+    queued: false,
+    jobId: null,
+    repoState: params.repoState,
+    changeStep: null,
+    collabTurn,
+    autoSync: null,
+    warnings: [CONVERSATION_ONLY_WARNING, ...collectWarnings(params.warnings ?? [])]
+  };
+}
 async function collabFinalizeTurn(params) {
   const repoRoot = await findGitRoot(params.cwd);
   const binding = await ensureActiveLaneBinding({
@@ -3171,6 +3476,24 @@ async function collabFinalizeTurn(params) {
 ` : "") + "Run `remix collab init` again to retry \u2014 the post-init drainer cleared the local binding so this is safe."
         });
       }
+      try {
+        return await recordConversationOnlyTurn({
+          api: params.api,
+          binding,
+          repoRoot,
+          prompt,
+          assistantResponse,
+          explicitIdempotencyKey: params.idempotencyKey,
+          actor: params.actor,
+          turnUsage: params.turnUsage,
+          promptedAt: params.promptedAt,
+          repoState: "init_post_pending",
+          materializationStatus: "skipped_init_post_pending",
+          alignmentRequired: "init_post",
+          warnings: [`Init post job ${pendingInitPost.id} is still pending; recorded conversation only.`]
+        });
+      } catch {
+      }
       throw new RemixError("Timed out waiting for the initial Remix import to finish provisioning.", {
         exitCode: 2,
         hint: `Init post job ${pendingInitPost.id} did not complete within ${Math.round(
@@ -3179,67 +3502,95 @@ async function collabFinalizeTurn(params) {
       });
     }
   }
-  const detected = await collabDetectRepoState({
+  let detected = await collabDetectRepoState({
     api: params.api,
     cwd: repoRoot,
     allowBranchMismatch: params.allowBranchMismatch
   });
-  if (detected.status === "not_bound") {
-    throw new RemixError("Repository is not bound to Remix.", {
-      code: "not_bound",
-      exitCode: 2,
-      hint: detected.hint
-    });
-  }
-  if (detected.status === "branch_binding_missing") {
-    throw new RemixError(detected.hint || "Current branch is not ready for Remix recording.", {
-      code: detected.status,
-      exitCode: 2,
-      hint: detected.hint
-    });
-  }
-  if (detected.status === "family_ambiguous") {
-    throw new RemixError(detected.hint || "Current branch is not ready for Remix recording.", {
-      code: detected.status,
-      exitCode: 2,
-      hint: detected.hint
-    });
-  }
-  if (detected.status === "metadata_conflict" || detected.status === "branch_mismatch") {
-    throw new RemixError("Repository must be realigned before finalizing the turn.", {
-      code: detected.status,
-      exitCode: 2,
-      hint: detected.hint
-    });
-  }
-  if (detected.status === "missing_head" || detected.status === "remote_error") {
-    const message = detected.hint || "Failed to determine the current repo state.";
-    throw new RemixError(message, {
-      code: detected.status,
-      exitCode: 1,
-      hint: detected.hint
+  throwBlockingDetectedStatus(detected);
+  let pendingFinalizeDrainWarnings = [];
+  if (detected.repoState === "server_only_changed" || detected.repoState === "both_changed") {
+    const recovery = await drainPendingFinalizeBeforeUnalignedFallback({
+      api: params.api,
+      repoRoot,
+      repoFingerprint: binding.repoFingerprint,
+      currentAppId: binding.currentAppId,
+      laneId: binding.laneId
     });
+    if (recovery.attempted) {
+      pendingFinalizeDrainWarnings = recovery.warnings;
+      detected = await collabDetectRepoState({
+        api: params.api,
+        cwd: repoRoot,
+        allowBranchMismatch: params.allowBranchMismatch
+      });
+      throwBlockingDetectedStatus(detected);
+    }
   }
-  if (detected.repoState === "server_only_changed") {
-    throw new RemixError("Server changes must be pulled locally before finalizing this turn.", {
-      code: "pull_required",
-      exitCode: 2,
-      hint: detected.hint
+  if (detected.status === "missing_head") {
+    return recordConversationOnlyTurn({
+      api: params.api,
+      binding,
+      repoRoot,
+      prompt,
+      assistantResponse,
+      explicitIdempotencyKey: params.idempotencyKey,
+      actor: params.actor,
+      turnUsage: params.turnUsage,
+      promptedAt: params.promptedAt,
+      repoState: "missing_head",
+      materializationStatus: "skipped_missing_head",
+      alignmentRequired: "head",
+      localCommitHash: null,
+      warnings: [...pendingFinalizeDrainWarnings, ...detected.warnings]
     });
   }
-  if (detected.repoState === "both_changed") {
-    const hint = detected.hint || "Run `remix collab reconcile --dry-run` to inspect recovery options before retrying.";
-    throw new RemixError("Local and server changes must be reconciled before finalizing this turn.", {
-      code: "reconcile_required",
-      exitCode: 2,
-      hint
+  if (detected.repoState === "server_only_changed" || detected.repoState === "both_changed") {
+    return recordConversationOnlyTurn({
+      api: params.api,
+      binding,
+      repoRoot,
+      prompt,
+      assistantResponse,
+      explicitIdempotencyKey: params.idempotencyKey,
+      actor: params.actor,
+      turnUsage: params.turnUsage,
+      promptedAt: params.promptedAt,
+      repoState: detected.repoState,
+      materializationStatus: "skipped_unaligned",
+      alignmentRequired: detected.repoState === "both_changed" ? "reconcile" : "sync",
+      baselineSnapshotId: detected.baseline.lastSnapshotId,
+      baselineServerRevisionId: detected.baseline.lastServerRevisionId,
+      baselineServerHeadHash: detected.baseline.lastServerHeadHash,
+      currentServerRevisionId: detected.currentServerRevisionId,
+      currentServerHeadHash: detected.currentServerHeadHash,
+      currentServerHeadCommitId: detected.currentServerHeadCommitId,
+      localCommitHash: detected.localCommitHash,
+      warnings: [...pendingFinalizeDrainWarnings, ...detected.warnings]
     });
   }
   if (detected.repoState === "external_local_base_changed") {
-    throw new RemixError("The local checkout is missing a Remix revision baseline for this lane.", {
-      code: "baseline_missing",
-      exitCode: 2,
-      hint: detected.hint
+    return recordConversationOnlyTurn({
+      api: params.api,
+      binding,
+      repoRoot,
+      prompt,
+      assistantResponse,
+      explicitIdempotencyKey: params.idempotencyKey,
+      actor: params.actor,
+      turnUsage: params.turnUsage,
+      promptedAt: params.promptedAt,
+      repoState: "external_local_base_changed",
+      materializationStatus: "skipped_baseline_missing",
+      alignmentRequired: "baseline",
+      baselineSnapshotId: detected.baseline.lastSnapshotId,
+      baselineServerRevisionId: detected.baseline.lastServerRevisionId,
+      baselineServerHeadHash: detected.baseline.lastServerHeadHash,
+      currentServerRevisionId: detected.currentServerRevisionId,
+      currentServerHeadHash: detected.currentServerHeadHash,
+      currentServerHeadCommitId: detected.currentServerHeadCommitId,
+      localCommitHash: detected.localCommitHash,
+      warnings: [...pendingFinalizeDrainWarnings, ...detected.warnings]
     });
   }
   const baseline = await readLocalBaseline({
@@ -3248,10 +3599,27 @@ async function collabFinalizeTurn(params) {
     repoRoot
   });
   if (!baseline) {
-    throw new RemixError("Local Remix baseline is missing for this lane.", {
-      code: "baseline_missing",
-      exitCode: 2,
-      hint: "Run `remix collab init` or sync this lane to create a fresh revision baseline."
+    return recordConversationOnlyTurn({
+      api: params.api,
+      binding,
+      repoRoot,
+      prompt,
+      assistantResponse,
+      explicitIdempotencyKey: params.idempotencyKey,
+      actor: params.actor,
+      turnUsage: params.turnUsage,
+      promptedAt: params.promptedAt,
+      repoState: "baseline_missing",
+      materializationStatus: "skipped_baseline_missing",
+      alignmentRequired: "baseline",
+      baselineSnapshotId: detected.baseline.lastSnapshotId,
+      baselineServerRevisionId: detected.baseline.lastServerRevisionId,
+      baselineServerHeadHash: detected.baseline.lastServerHeadHash,
+      currentServerRevisionId: detected.currentServerRevisionId,
+      currentServerHeadHash: detected.currentServerHeadHash,
+      currentServerHeadCommitId: detected.currentServerHeadCommitId,
+      localCommitHash: detected.localCommitHash,
+      warnings: [...pendingFinalizeDrainWarnings, ...detected.warnings]
     });
   }
   const snapshot = await captureLocalSnapshot({
@@ -3309,7 +3677,7 @@ async function collabFinalizeTurn(params) {
     changeStep: null,
     collabTurn: null,
     autoSync: null,
-    warnings: [FINALIZE_QUEUED_WARNING, ...collectWarnings(detected.warnings)]
+    warnings: [FINALIZE_QUEUED_WARNING, ...collectWarnings([...pendingFinalizeDrainWarnings, ...detected.warnings])]
   };
 }
 

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

@@ -135,7 +135,7 @@ type MergeRequestReview = {
 type CollabApproveMode = "remote-only" | "sync-target-repo";
 type CollabApprovalStrategy = "ai_patch_apply" | "git_merge_auto_resolve" | "git_merge_manual_resolution";
 type CollabStatusBlockedReason = "not_git_repo" | "not_bound" | "branch_binding_missing" | "family_ambiguous" | "missing_head" | "detached_head" | "branch_mismatch" | "dirty_worktree" | "baseline_missing" | "metadata_conflict" | "remote_error";
-type CollabRepoStateKind = "idle" | "local_only_changed" | "server_only_changed" | "both_changed" | "external_local_base_changed" | "metadata_conflict" | "binding_problem";
+type CollabRepoStateKind = "idle" | "local_only_changed" | "server_only_changed" | "both_changed" | "external_local_base_changed" | "baseline_missing" | "missing_head" | "init_post_pending" | "metadata_conflict" | "binding_problem";
 type CollabPendingFinalizeState = "idle" | "queued" | "processing" | "retry_scheduled" | "awaiting_usage" | "failed";
 type CollabPendingFinalizeSummary = {
     state: CollabPendingFinalizeState;
@@ -382,7 +382,7 @@ type CollabTurn = {
     prompt: string | null;
     assistantResponse: string | null;
 };
-type CollabFinalizeTurnMode = "changed_turn" | "no_diff_turn";
+type CollabFinalizeTurnMode = "changed_turn" | "no_diff_turn" | "conversation_only";
 type CollabFinalizeTurnAutoSync = {
     requested: boolean;
     eligible: boolean;

package/dist/history.d.ts

@@ -1,4 +1,4 @@
-import { T as TurnUsage } from './contracts-WCYiMqwB.js';
+import { T as TurnUsage } from './contracts-BqC3Lj7W.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, Bundle, BundlePlatform, BundleStatus, ChangeStepDiffResponse, 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-WCYiMqwB.js';
+import './contracts-BqC3Lj7W.js';

package/package.json

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