open-research-protocol 0.4.33 → 0.4.35

package/packages/orp-workspace-launcher/src/orp.js

@@ -218,6 +218,22 @@ export function findHostedWorkspaceLinkedToIdea(workspaces = [], ideaId) {
   );
 }
 
+export function findHostedWorkspaceByWorkspaceId(workspaces = [], workspaceId) {
+  const targetWorkspaceId = normalizeOptionalString(workspaceId);
+  if (!targetWorkspaceId || !Array.isArray(workspaces)) {
+    return null;
+  }
+
+  return (
+    workspaces.find((workspace) => {
+      if (!workspace || typeof workspace !== "object" || Array.isArray(workspace)) {
+        return false;
+      }
+      return normalizeOptionalString(workspace.workspace_id ?? workspace.id) === targetWorkspaceId;
+    }) || null
+  );
+}
+
 export async function findHostedWorkspaceByLinkedIdea(ideaId, options = {}) {
   const payload = await fetchHostedWorkspacesPayload(options);
   return findHostedWorkspaceLinkedToIdea(payload.workspaces, ideaId);
@@ -742,6 +758,13 @@ export function buildWorkspaceManifestFromHostedWorkspacePayload(payload) {
           resumeSessionId: getTextValue(tab, "resume_session_id", "resumeSessionId"),
           codexSessionId: getTextValue(tab, "codex_session_id", "codexSessionId"),
           tmuxSessionName: getTextValue(tab, "tmux_session_name", "tmuxSessionName"),
+          linkedIdeaId: getTextValue(tab, "linked_idea_id", "linkedIdeaId"),
+          linkedFeatureId: getTextValue(tab, "linked_feature_id", "linkedFeatureId"),
+          plan: getObjectValue(tab, "plan") || undefined,
+          tasks: getArrayValue(tab, "tasks").length > 0 ? getArrayValue(tab, "tasks") : undefined,
+          lastActivityAt: getTextValue(tab, "last_activity_at_utc", "lastActivityAtUtc"),
+          lastSyncedAt: getTextValue(tab, "last_synced_at_utc", "lastSyncedAtUtc"),
+          syncSource: getTextValue(tab, "sync_source", "syncSource"),
         }).filter(([, value]) => value !== undefined && value !== null),
       ),
     ),

package/packages/orp-workspace-launcher/src/registry.js

@@ -53,12 +53,14 @@ function buildResumeSessionRows(tabs) {
         Object.entries({
           title: normalizeOptionalString(tab.title) ?? undefined,
           path: normalizeOptionalString(tab.path) ?? undefined,
-          resumeCommand: resumeCommand ?? undefined,
-          resumeTool: resumeTool ?? undefined,
-          resumeSessionId: resumeSessionId ?? undefined,
-          codexSessionId: resumeTool === "codex" ? resumeSessionId ?? undefined : undefined,
-        }).filter(([, value]) => value !== undefined),
-      );
+            resumeCommand: resumeCommand ?? undefined,
+            resumeTool: resumeTool ?? undefined,
+            resumeSessionId: resumeSessionId ?? undefined,
+            codexSessionId: resumeTool === "codex" ? resumeSessionId ?? undefined : undefined,
+            lastActivityAt: normalizeOptionalString(tab.lastActivityAt ?? tab.last_activity_at_utc) ?? undefined,
+            lastSyncedAt: normalizeOptionalString(tab.lastSyncedAt ?? tab.last_synced_at_utc) ?? undefined,
+          }).filter(([, value]) => value !== undefined),
+        );
     })
     .filter(Boolean);
 }
@@ -112,11 +114,13 @@ function normalizeRegistryEntry(rawEntry) {
                   title: normalizeOptionalString(session.title) ?? undefined,
                   path: normalizeOptionalString(session.path) ?? undefined,
                   resumeCommand: resumeCommand ?? undefined,
-                  resumeTool: normalizeOptionalString(session.resumeTool) ?? undefined,
-                  resumeSessionId: resumeSessionId ?? undefined,
-                  codexSessionId: normalizeOptionalString(session.codexSessionId) ?? undefined,
-                }).filter(([, value]) => value !== undefined),
-              );
+            resumeTool: normalizeOptionalString(session.resumeTool) ?? undefined,
+            resumeSessionId: resumeSessionId ?? undefined,
+            codexSessionId: normalizeOptionalString(session.codexSessionId) ?? undefined,
+            lastActivityAt: normalizeOptionalString(session.lastActivityAt ?? session.last_activity_at_utc) ?? undefined,
+            lastSyncedAt: normalizeOptionalString(session.lastSyncedAt ?? session.last_synced_at_utc) ?? undefined,
+          }).filter(([, value]) => value !== undefined),
+        );
             })
             .filter(Boolean)
         : Array.isArray(rawEntry.codexSessions)
@@ -137,6 +141,8 @@ function normalizeRegistryEntry(rawEntry) {
                   resumeTool: codexSessionId ? "codex" : undefined,
                   resumeSessionId: codexSessionId,
                   codexSessionId,
+                  lastActivityAt: normalizeOptionalString(session.lastActivityAt ?? session.last_activity_at_utc) ?? undefined,
+                  lastSyncedAt: normalizeOptionalString(session.lastSyncedAt ?? session.last_synced_at_utc) ?? undefined,
                 }).filter(([, value]) => value !== undefined),
               );
             })
@@ -351,6 +357,13 @@ function serializeManagedWorkspaceManifest(manifest) {
             resumeSessionId: resumeSessionId ?? undefined,
             codexSessionId: resumeTool === "codex" ? resumeSessionId ?? undefined : undefined,
             claudeSessionId: resumeTool === "claude" ? resumeSessionId ?? undefined : undefined,
+            linkedIdeaId: normalizeOptionalString(tab.linkedIdeaId ?? tab.linked_idea_id) ?? undefined,
+            linkedFeatureId: normalizeOptionalString(tab.linkedFeatureId ?? tab.linked_feature_id) ?? undefined,
+            plan: tab.plan && typeof tab.plan === "object" && !Array.isArray(tab.plan) ? tab.plan : undefined,
+            tasks: Array.isArray(tab.tasks) && tab.tasks.length > 0 ? tab.tasks : undefined,
+            lastActivityAt: normalizeOptionalString(tab.lastActivityAt ?? tab.last_activity_at_utc) ?? undefined,
+            lastSyncedAt: normalizeOptionalString(tab.lastSyncedAt ?? tab.last_synced_at_utc) ?? undefined,
+            syncSource: normalizeOptionalString(tab.syncSource ?? tab.sync_source) ?? undefined,
           }).filter(([, value]) => value !== undefined),
         );
       })

package/packages/orp-workspace-launcher/src/sync.js

@@ -10,11 +10,22 @@ import {
   resolveResumeMetadata,
   WORKSPACE_SCHEMA_VERSION,
 } from "./core-plan.js";
-import { fetchIdeaPayload, loadWorkspaceSource, updateIdeaPayload } from "./orp.js";
+import { buildHostedWorkspaceState, enrichWorkspaceManifestWithProjectContext } from "./hosted-state.js";
+import { mergeLocalProjectInventoryIntoManifest } from "./local-inventory.js";
+import {
+  buildWorkspaceManifestFromHostedWorkspacePayload,
+  fetchHostedWorkspacesPayload,
+  fetchIdeaPayload,
+  findHostedWorkspaceByWorkspaceId,
+  loadWorkspaceSource,
+  pushHostedWorkspaceState,
+  updateIdeaPayload,
+} from "./orp.js";
 import { cacheManagedWorkspaceManifest } from "./registry.js";
 
 const STRUCTURED_WORKSPACE_BLOCK_PATTERN = /```orp-workspace\s*[\s\S]*?```/i;
 const WORKSPACE_TITLE_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const MAX_HOSTED_IDEA_NOTES_LENGTH = 9500;
 
 function printSyncHelp() {
   console.log(`ORP workspace sync
@@ -128,11 +139,38 @@ async function resolveWorkspaceSyncTargetSource(source, options) {
   if (!options.workspaceFile && !options.notesFile && (source.sourceType === "hosted-idea" || source.sourceType === "hosted-workspace")) {
     return source;
   }
-  return loadWorkspaceSource({
+  const targetSource = await loadWorkspaceSource({
     ideaId: options.ideaId,
     baseUrl: options.baseUrl,
     orpCommand: options.orpCommand,
   });
+  if (targetSource.sourceType !== "workspace-file") {
+    return targetSource;
+  }
+
+  const workspaceId =
+    normalizeOptionalString(source.workspaceManifest?.workspaceId) ||
+    normalizeOptionalString(targetSource.workspaceManifest?.workspaceId);
+  if (!workspaceId) {
+    return targetSource;
+  }
+
+  const payload = await fetchHostedWorkspacesPayload(options).catch(() => null);
+  const hostedWorkspace = findHostedWorkspaceByWorkspaceId(payload?.workspaces || [], workspaceId);
+  if (!hostedWorkspace) {
+    return targetSource;
+  }
+
+  return {
+    sourceType: "hosted-workspace",
+    sourceLabel: hostedWorkspace.title || workspaceId,
+    title: hostedWorkspace.title || workspaceId,
+    workspaceManifest: buildWorkspaceManifestFromHostedWorkspacePayload(hostedWorkspace),
+    notes: "",
+    hostedWorkspace,
+    payload: { ok: true, workspace: hostedWorkspace },
+    bridgedFromLocalWorkspaceFile: targetSource.sourcePath || targetSource.sourceLabel || true,
+  };
 }
 
 export function validateWorkspaceTitle(value, label = "--title") {
@@ -198,6 +236,15 @@ function serializeWorkspaceManifest(manifest) {
         resumeCommand: normalizeOptionalString(entry.resumeCommand) ?? undefined,
         resumeTool: normalizeOptionalString(entry.resumeTool) ?? undefined,
         resumeSessionId: normalizeOptionalString(entry.resumeSessionId ?? entry.sessionId) ?? undefined,
+        linkedIdeaId: normalizeOptionalString(entry.linkedIdeaId ?? entry.linked_idea_id) ?? undefined,
+        linkedFeatureId: normalizeOptionalString(entry.linkedFeatureId ?? entry.linked_feature_id) ?? undefined,
+        plan: entry.plan && typeof entry.plan === "object" && !Array.isArray(entry.plan) ? entry.plan : undefined,
+        tasks: Array.isArray(entry.tasks) && entry.tasks.length > 0 ? entry.tasks : undefined,
+        lastActivityAt:
+          normalizeOptionalString(entry.lastActivityAt ?? entry.last_activity_at_utc ?? entry.lastActivityAtUtc) ?? undefined,
+        lastSyncedAt:
+          normalizeOptionalString(entry.lastSyncedAt ?? entry.last_synced_at_utc ?? entry.lastSyncedAtUtc) ?? undefined,
+        syncSource: normalizeOptionalString(entry.syncSource ?? entry.sync_source) ?? undefined,
         codexSessionId:
           normalizeOptionalString(entry.resumeTool) === "codex"
             ? normalizeOptionalString(entry.codexSessionId ?? entry.resumeSessionId ?? entry.sessionId) ?? undefined
@@ -232,6 +279,110 @@ function composeWorkspaceNotes({ narrativeNotes, manifest }) {
   ]);
 }
 
+function serializeCompactWorkspaceManifest(manifest, options = {}) {
+  const tabs = manifest.tabs.map((entry) =>
+    Object.fromEntries(
+      Object.entries({
+        title: normalizeOptionalString(entry.title) ?? undefined,
+        path: String(entry.path).trim(),
+        remoteUrl: normalizeOptionalString(entry.remoteUrl) ?? undefined,
+        remoteBranch: normalizeOptionalString(entry.remoteBranch) ?? undefined,
+        bootstrapCommand: normalizeOptionalString(entry.bootstrapCommand) ?? undefined,
+        resumeCommand: normalizeOptionalString(entry.resumeCommand) ?? undefined,
+        resumeTool: normalizeOptionalString(entry.resumeTool) ?? undefined,
+        resumeSessionId: normalizeOptionalString(entry.resumeSessionId ?? entry.sessionId) ?? undefined,
+        linkedIdeaId: normalizeOptionalString(entry.linkedIdeaId ?? entry.linked_idea_id) ?? undefined,
+        linkedFeatureId: normalizeOptionalString(entry.linkedFeatureId ?? entry.linked_feature_id) ?? undefined,
+        lastActivityAt:
+          normalizeOptionalString(entry.lastActivityAt ?? entry.last_activity_at_utc ?? entry.lastActivityAtUtc) ?? undefined,
+        lastSyncedAt:
+          normalizeOptionalString(entry.lastSyncedAt ?? entry.last_synced_at_utc ?? entry.lastSyncedAtUtc) ?? undefined,
+      }).filter(([, value]) => value !== undefined),
+    ),
+  );
+
+  return JSON.stringify(
+    Object.fromEntries(
+      Object.entries({
+        version: WORKSPACE_SCHEMA_VERSION,
+        workspaceId: normalizeOptionalString(manifest.workspaceId) ?? undefined,
+        title: normalizeOptionalString(manifest.title) ?? undefined,
+        source: "hosted-workspace",
+        hostedWorkspaceId: normalizeOptionalString(options.hostedWorkspaceId) ?? undefined,
+        tabCount: tabs.length,
+        projectCount: new Set(tabs.map((tab) => tab.path).filter(Boolean)).size,
+        tabs,
+      }).filter(([, value]) => value !== undefined),
+    ),
+    null,
+    2,
+  );
+}
+
+function buildStoredIdeaNotes({ narrativeNotes, manifest, hostedWorkspaceId }) {
+  const fullNotes = composeWorkspaceNotes({ narrativeNotes, manifest });
+  if (fullNotes.length <= MAX_HOSTED_IDEA_NOTES_LENGTH) {
+    return {
+      notes: fullNotes,
+      compacted: false,
+      omittedPlanTaskDetails: false,
+    };
+  }
+
+  const compactManifest = serializeCompactWorkspaceManifest(manifest, { hostedWorkspaceId });
+  const compactNotes = combineNoteSections([
+    narrativeNotes,
+    hostedWorkspaceId
+      ? `Full workspace state, including plans and tasks, is stored on hosted ORP workspace ${hostedWorkspaceId}.`
+      : "Full workspace plan and task state is omitted from this idea-note compatibility mirror.",
+    `\`\`\`orp-workspace\n${compactManifest}\n\`\`\``,
+  ]);
+  if (compactNotes.length <= MAX_HOSTED_IDEA_NOTES_LENGTH) {
+    return {
+      notes: compactNotes,
+      compacted: true,
+      omittedPlanTaskDetails: true,
+    };
+  }
+
+  const buildPointerManifest = (includeTabs) => ({
+      version: WORKSPACE_SCHEMA_VERSION,
+      workspaceId: normalizeOptionalString(manifest.workspaceId),
+      title: normalizeOptionalString(manifest.title),
+      source: "hosted-workspace",
+      hostedWorkspaceId: normalizeOptionalString(hostedWorkspaceId),
+      tabCount: Array.isArray(manifest.tabs) ? manifest.tabs.length : 0,
+      projectCount: new Set((manifest.tabs || []).map((tab) => tab.path).filter(Boolean)).size,
+      tabs: includeTabs
+        ? (manifest.tabs || []).map((tab) =>
+            Object.fromEntries(
+              Object.entries({
+                title: normalizeOptionalString(tab.title) ?? undefined,
+                path: normalizeOptionalString(tab.path) ?? undefined,
+              }).filter(([, value]) => value !== undefined),
+            ),
+          )
+        : undefined,
+  });
+  const pointerText = (includeTabs) => JSON.stringify(buildPointerManifest(includeTabs), null, 2);
+  const pointerNotes = (includeTabs) =>
+    combineNoteSections([
+      narrativeNotes,
+      hostedWorkspaceId
+        ? `Full workspace state is stored on hosted ORP workspace ${hostedWorkspaceId}.`
+        : "Full workspace state is stored in the ORP workspace sync payload.",
+      `\`\`\`orp-workspace\n${pointerText(includeTabs)}\n\`\`\``,
+    ]);
+  return {
+    notes:
+      pointerNotes(true).length <= MAX_HOSTED_IDEA_NOTES_LENGTH
+        ? pointerNotes(true)
+        : pointerNotes(false),
+    compacted: true,
+    omittedPlanTaskDetails: true,
+  };
+}
+
 export function buildWorkspaceSyncPreview({ source, parsed, targetIdea, workspaceTitle = null }) {
   const manifest = parsed.manifest
     ? {
@@ -250,6 +401,13 @@ export function buildWorkspaceSyncPreview({ source, parsed, targetIdea, workspac
           resumeSessionId: entry.sessionId || null,
           codexSessionId: entry.resumeTool === "codex" ? entry.sessionId || null : null,
           claudeSessionId: entry.resumeTool === "claude" ? entry.sessionId || null : null,
+          linkedIdeaId: entry.linkedIdeaId || null,
+          linkedFeatureId: entry.linkedFeatureId || null,
+          plan: entry.plan || null,
+          tasks: Array.isArray(entry.tasks) ? entry.tasks : [],
+          lastActivityAt: entry.lastActivityAt || null,
+          lastSyncedAt: entry.lastSyncedAt || null,
+          syncSource: entry.syncSource || null,
         })),
       }
     : {
@@ -270,8 +428,20 @@ export function buildWorkspaceSyncPreview({ source, parsed, targetIdea, workspac
             resolveResumeMetadata(entry).resumeTool === "codex" ? resolveResumeMetadata(entry).resumeSessionId : null,
           claudeSessionId:
             resolveResumeMetadata(entry).resumeTool === "claude" ? resolveResumeMetadata(entry).resumeSessionId : null,
+          lastActivityAt: entry.lastActivityAt || null,
+          lastSyncedAt: entry.lastSyncedAt || null,
+          syncSource: entry.syncSource || null,
         })),
       };
+  const syncTimestamp = new Date().toISOString();
+  const timestampedManifest = {
+    ...manifest,
+    tabs: manifest.tabs.map((tab) => ({
+      ...tab,
+      lastSyncedAt: tab.lastSyncedAt || syncTimestamp,
+    })),
+  };
+  const enrichedManifest = enrichWorkspaceManifestWithProjectContext(timestampedManifest);
 
   const narrativeSourceNotes =
     source.sourceType === "workspace-file" ? targetIdea.notes || "" : source.notes || targetIdea.notes || "";
@@ -280,7 +450,7 @@ export function buildWorkspaceSyncPreview({ source, parsed, targetIdea, workspac
   });
   const nextNotes = composeWorkspaceNotes({
     narrativeNotes,
-    manifest,
+    manifest: enrichedManifest,
   });
 
   return {
@@ -289,11 +459,11 @@ export function buildWorkspaceSyncPreview({ source, parsed, targetIdea, workspac
     sourceType: source.sourceType,
     sourceLabel: source.sourceLabel,
     parseMode: parsed.parseMode,
-    workspaceId: manifest.workspaceId,
-    manifest,
+    workspaceId: enrichedManifest.workspaceId,
+    manifest: enrichedManifest,
     nextNotes,
     nextNotesLength: nextNotes.length,
-    tabs: manifest.tabs,
+    tabs: enrichedManifest.tabs,
     skipped: parsed.skipped,
   };
 }
@@ -308,10 +478,19 @@ function summarizeSyncPreview(preview) {
     `  tabs: ${preview.tabs.length}`,
     `  stored notes: ${preview.nextNotesLength} chars`,
   ];
+  if (preview.compactedIdeaNotes) {
+    lines.push(`  idea notes: compact compatibility mirror; hosted workspace state carries full details`);
+  }
+  if (preview.hostedWorkspaceId) {
+    lines.push(`  hosted push target: ${preview.hostedWorkspaceId}`);
+  }
 
   if (preview.skipped.length > 0) {
     lines.push(`  skipped non-path lines: ${preview.skipped.length}`);
   }
+  if (preview.inventory) {
+    lines.push(`  local inventory: ${preview.inventory.rowCount} rows / ${preview.inventory.projectCount} projects`);
+  }
   return lines.join("\n");
 }
 
@@ -330,10 +509,12 @@ export async function runWorkspaceSync(argv = process.argv.slice(2)) {
   if (parsed.entries.length === 0) {
     throw new Error("No launchable workspace lines were found in the provided source.");
   }
+  const targetSource = await resolveWorkspaceSyncTargetSource(source, options);
   const resolvedWorkspaceTitle = options.title
     ? validateWorkspaceTitle(options.title)
-    : normalizeOptionalString(parsed.manifest?.title) || (await promptForWorkspaceTitle());
-  const targetSource = await resolveWorkspaceSyncTargetSource(source, options);
+    : normalizeOptionalString(targetSource.hostedWorkspace?.title) ||
+      normalizeOptionalString(parsed.manifest?.title) ||
+      (await promptForWorkspaceTitle());
   const targetIdeaId = resolveWorkspaceSyncTargetIdeaId(targetSource);
   if (!targetIdeaId) {
     throw new Error(
@@ -356,23 +537,69 @@ export async function runWorkspaceSync(argv = process.argv.slice(2)) {
     targetIdea: targetPayload.idea,
     workspaceTitle: resolvedWorkspaceTitle,
   });
+  const reconciled = await mergeLocalProjectInventoryIntoManifest(preview.manifest, {
+    ...options,
+    workspaceSelector: options.ideaId,
+  });
+  const hostedWorkspaceId = normalizeOptionalString(targetSource.hostedWorkspace?.workspace_id ?? targetSource.hostedWorkspace?.id);
+  const narrativeNotes = extractWorkspaceNarrativeNotes(preview.nextNotes, {
+    stripLegacyWorkspaceLines: true,
+  });
+  const storedIdeaNotes = buildStoredIdeaNotes({
+    narrativeNotes,
+    manifest: reconciled.manifest,
+    hostedWorkspaceId,
+  });
+  const finalPreview = {
+    ...preview,
+    manifest: reconciled.manifest,
+    tabs: reconciled.manifest.tabs,
+    nextNotes: storedIdeaNotes.notes,
+    inventory: reconciled.inventory,
+    hostedWorkspaceId,
+    compactedIdeaNotes: storedIdeaNotes.compacted,
+    omittedPlanTaskDetailsFromIdeaNotes: storedIdeaNotes.omittedPlanTaskDetails,
+  };
+  finalPreview.nextNotesLength = finalPreview.nextNotes.length;
 
   if (options.json) {
-    process.stdout.write(`${JSON.stringify(preview, null, 2)}\n`);
+    process.stdout.write(`${JSON.stringify(finalPreview, null, 2)}\n`);
     return 0;
   }
 
   if (options.dryRun) {
-    process.stdout.write(`${summarizeSyncPreview(preview)}\n`);
+    process.stdout.write(`${summarizeSyncPreview(finalPreview)}\n`);
     return 0;
   }
 
-  const updated = await updateIdeaPayload(targetIdeaId, { notes: preview.nextNotes }, options);
-  const managedCache = await cacheManagedWorkspaceManifest(preview.manifest);
+  let pushedWorkspace = null;
+  if (hostedWorkspaceId) {
+    const state = buildHostedWorkspaceState(finalPreview.manifest, {
+      previousWorkspace: targetSource.hostedWorkspace,
+      updatedAt: new Date().toISOString(),
+      localInventory: finalPreview.inventory,
+    });
+    const pushed = await pushHostedWorkspaceState(hostedWorkspaceId, state, options);
+    pushedWorkspace = pushed?.workspace || null;
+  }
+  const updated = hostedWorkspaceId
+    ? { title: finalPreview.targetIdeaTitle }
+    : await updateIdeaPayload(targetIdeaId, { notes: finalPreview.nextNotes }, options);
+  const managedCache = await cacheManagedWorkspaceManifest(finalPreview.manifest);
   process.stdout.write(
-    `Synced workspace '${preview.workspaceId}' to idea '${updated.title || preview.targetIdeaTitle}'.\n`,
+    `Synced workspace '${finalPreview.workspaceId}' to idea '${updated.title || finalPreview.targetIdeaTitle}'.\n`,
   );
-  process.stdout.write(`Tabs: ${preview.tabs.length}. Stored notes: ${preview.nextNotesLength} chars.\n`);
+  if (pushedWorkspace) {
+    process.stdout.write(`Pushed hosted workspace state to '${hostedWorkspaceId}'.\n`);
+    process.stdout.write("Skipped idea-note mirror update because hosted workspace state is authoritative.\n");
+  }
+  if (hostedWorkspaceId) {
+    process.stdout.write(
+      `Tabs: ${finalPreview.tabs.length}. Compatibility notes would be ${finalPreview.nextNotesLength} chars.\n`,
+    );
+  } else {
+    process.stdout.write(`Tabs: ${finalPreview.tabs.length}. Stored notes: ${finalPreview.nextNotesLength} chars.\n`);
+  }
   process.stdout.write(`Updated local workspace cache at ${managedCache.manifestPath}.\n`);
   return 0;
 }

package/packages/orp-workspace-launcher/test/core-plan.test.js

@@ -1,5 +1,8 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 
 import {
   buildLaunchPlan,
@@ -243,6 +246,51 @@ Workspace summary.
   assert.doesNotMatch(preview.nextNotes, /\/Volumes\/Code_2TB\/code\/orp: codex resume/);
 });
 
+test("buildWorkspaceSyncPreview enriches workspace-file tabs with linked ORP project context", async () => {
+  const projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), "orp-workspace-sync-frontier-"));
+  await fs.mkdir(path.join(projectRoot, ".git", "orp", "link"), { recursive: true });
+  await fs.writeFile(
+    path.join(projectRoot, ".git", "orp", "link", "project.json"),
+    JSON.stringify(
+      {
+        idea_id: "idea-linked",
+        active_feature_id: "feature-active",
+        project_root: projectRoot,
+      },
+      null,
+      2,
+    ),
+    "utf8",
+  );
+  const source = {
+    sourceType: "workspace-file",
+    sourceLabel: "/tmp/workspace.json",
+    sourcePath: "/tmp/workspace.json",
+    title: "Workspace idea",
+    notes: "",
+    workspaceManifest: {
+      version: "1",
+      workspaceId: "workspace-file-demo",
+      tabs: [{ title: "Linked project", path: projectRoot }],
+    },
+  };
+  const parsed = parseWorkspaceSource(source);
+  const preview = buildWorkspaceSyncPreview({
+    source,
+    parsed,
+    targetIdea: {
+      id: "idea-123",
+      title: "Workspace idea",
+      notes: "",
+    },
+  });
+
+  assert.equal(preview.tabs[0]?.linkedIdeaId, "idea-linked");
+  assert.equal(preview.tabs[0]?.linkedFeatureId, "feature-active");
+  assert.match(preview.nextNotes, /"linkedIdeaId": "idea-linked"/);
+  assert.match(preview.nextNotes, /"linkedFeatureId": "feature-active"/);
+});
+
 test("resolveWorkspaceSyncTargetIdeaId supports hosted idea and hosted workspace sources", () => {
   assert.equal(
     resolveWorkspaceSyncTargetIdeaId({