@remixhq/core 0.1.34 → 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

@@ -3240,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({
@@ -3313,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(
@@ -3321,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({
@@ -3390,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({
@@ -3451,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.34",
+  "version": "0.1.35",
   "description": "Remix core library",
   "homepage": "https://github.com/RemixDotOne/remix-core",
   "license": "MIT",