open-research-protocol 0.4.32 → 0.4.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-research-protocol",
-  "version": "0.4.32",
+  "version": "0.4.34",
   "description": "ORP CLI (Open Research Protocol): workspace ledgers, secrets, scheduling, governed execution, and agent-friendly research workflows.",
   "license": "MIT",
   "author": "Fractal Research Group <cody@frg.earth>",

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

@@ -265,6 +265,8 @@ function normalizeStructuredTab(rawTab, index) {
   const title = normalizeOptionalString(rawTab.title);
   const resume = resolveResumeMetadata(rawTab);
   const tmuxSessionName = normalizeOptionalString(rawTab.tmuxSessionName);
+  const plan = rawTab.plan && typeof rawTab.plan === "object" && !Array.isArray(rawTab.plan) ? rawTab.plan : null;
+  const tasks = Array.isArray(rawTab.tasks) ? rawTab.tasks : [];
 
   return {
     lineNumber: index + 1,
@@ -279,6 +281,10 @@ function normalizeStructuredTab(rawTab, index) {
     remoteUrl: normalizeOptionalUrl(rawTab.remoteUrl, `workspace tab ${index + 1} remoteUrl`),
     remoteBranch: normalizeOptionalString(rawTab.remoteBranch),
     bootstrapCommand: normalizeOptionalCommand(rawTab.bootstrapCommand),
+    linkedIdeaId: normalizeOptionalString(rawTab.linkedIdeaId ?? rawTab.linked_idea_id),
+    linkedFeatureId: normalizeOptionalString(rawTab.linkedFeatureId ?? rawTab.linked_feature_id),
+    plan,
+    tasks,
   };
 }
 
@@ -307,6 +313,14 @@ function normalizeStructuredProject(rawProject, projectIndex) {
         codexSessionId: rawSession.codexSessionId,
         claudeSessionId: rawSession.claudeSessionId,
         tmuxSessionName: rawSession.tmuxSessionName,
+        linkedIdeaId: rawSession.linkedIdeaId ?? rawSession.linked_idea_id ?? rawProject.linkedIdeaId ?? rawProject.linked_idea_id,
+        linkedFeatureId:
+          rawSession.linkedFeatureId ??
+          rawSession.linked_feature_id ??
+          rawProject.linkedFeatureId ??
+          rawProject.linked_feature_id,
+        plan: rawSession.plan ?? rawProject.plan,
+        tasks: rawSession.tasks ?? rawProject.tasks,
       },
       sessionIndex,
     );
@@ -381,6 +395,10 @@ export function buildWorkspaceProjectGroups(entries = []) {
         remoteUrl: normalizeOptionalUrl(entry.remoteUrl, "workspace project remoteUrl"),
         remoteBranch: normalizeOptionalString(entry.remoteBranch),
         bootstrapCommand: normalizeOptionalCommand(entry.bootstrapCommand),
+        linkedIdeaId: normalizeOptionalString(entry.linkedIdeaId),
+        linkedFeatureId: normalizeOptionalString(entry.linkedFeatureId),
+        plan: entry.plan && typeof entry.plan === "object" && !Array.isArray(entry.plan) ? entry.plan : null,
+        tasks: Array.isArray(entry.tasks) && entry.tasks.length > 0 ? entry.tasks : [],
         sessions: [],
       });
     }
@@ -389,6 +407,14 @@ export function buildWorkspaceProjectGroups(entries = []) {
     project.remoteUrl = project.remoteUrl || normalizeOptionalUrl(entry.remoteUrl, "workspace project remoteUrl");
     project.remoteBranch = project.remoteBranch || normalizeOptionalString(entry.remoteBranch);
     project.bootstrapCommand = project.bootstrapCommand || normalizeOptionalCommand(entry.bootstrapCommand);
+    project.linkedIdeaId = project.linkedIdeaId || normalizeOptionalString(entry.linkedIdeaId);
+    project.linkedFeatureId = project.linkedFeatureId || normalizeOptionalString(entry.linkedFeatureId);
+    project.plan =
+      project.plan ||
+      (entry.plan && typeof entry.plan === "object" && !Array.isArray(entry.plan) ? entry.plan : null);
+    if ((!Array.isArray(project.tasks) || project.tasks.length === 0) && Array.isArray(entry.tasks) && entry.tasks.length > 0) {
+      project.tasks = entry.tasks;
+    }
 
     const resume = resolveResumeMetadata(entry);
     project.sessions.push(
@@ -413,6 +439,10 @@ export function buildWorkspaceProjectGroups(entries = []) {
         remoteUrl: project.remoteUrl || undefined,
         remoteBranch: project.remoteBranch || undefined,
         bootstrapCommand: project.bootstrapCommand || undefined,
+        linkedIdeaId: project.linkedIdeaId || undefined,
+        linkedFeatureId: project.linkedFeatureId || undefined,
+        plan: project.plan || undefined,
+        tasks: Array.isArray(project.tasks) && project.tasks.length > 0 ? project.tasks : undefined,
         sessionCount: project.sessions.length,
         sessions: project.sessions,
       }).filter(([, value]) => value !== undefined),

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

@@ -1,6 +1,7 @@
 import os from "node:os";
 import path from "node:path";
 import crypto from "node:crypto";
+import fs from "node:fs";
 
 import { resolveResumeMetadata } from "./core-plan.js";
 
@@ -73,6 +74,8 @@ function normalizePreviousHostedTabs(workspace) {
       lastActivityAt: normalizeOptionalString(tab.last_activity_at_utc ?? tab.lastActivityAtUtc),
       linkedIdeaId: normalizeOptionalString(tab.linked_idea_id ?? tab.linkedIdeaId),
       linkedFeatureId: normalizeOptionalString(tab.linked_feature_id ?? tab.linkedFeatureId),
+      plan: tab.plan && typeof tab.plan === "object" && !Array.isArray(tab.plan) ? tab.plan : null,
+      tasks: Array.isArray(tab.tasks) ? tab.tasks : [],
       used: false,
     };
   });
@@ -111,6 +114,10 @@ function buildHostedProjectGroups(tabs) {
         remote_url: normalizeOptionalString(tab.remote_url),
         remote_branch: normalizeOptionalString(tab.remote_branch),
         bootstrap_command: normalizeOptionalString(tab.bootstrap_command),
+        linked_idea_id: normalizeOptionalString(tab.linked_idea_id),
+        linked_feature_id: normalizeOptionalString(tab.linked_feature_id),
+        plan: tab.plan && typeof tab.plan === "object" && !Array.isArray(tab.plan) ? tab.plan : undefined,
+        tasks: Array.isArray(tab.tasks) ? tab.tasks : undefined,
         sessions: [],
       });
     }
@@ -118,6 +125,12 @@ function buildHostedProjectGroups(tabs) {
     project.remote_url = project.remote_url || normalizeOptionalString(tab.remote_url);
     project.remote_branch = project.remote_branch || normalizeOptionalString(tab.remote_branch);
     project.bootstrap_command = project.bootstrap_command || normalizeOptionalString(tab.bootstrap_command);
+    project.linked_idea_id = project.linked_idea_id || normalizeOptionalString(tab.linked_idea_id);
+    project.linked_feature_id = project.linked_feature_id || normalizeOptionalString(tab.linked_feature_id);
+    project.plan = project.plan || (tab.plan && typeof tab.plan === "object" && !Array.isArray(tab.plan) ? tab.plan : undefined);
+    if ((!Array.isArray(project.tasks) || project.tasks.length === 0) && Array.isArray(tab.tasks) && tab.tasks.length > 0) {
+      project.tasks = tab.tasks;
+    }
     project.sessions.push(
       Object.fromEntries(
         Object.entries({
@@ -143,6 +156,10 @@ function buildHostedProjectGroups(tabs) {
         remote_url: project.remote_url || undefined,
         remote_branch: project.remote_branch || undefined,
         bootstrap_command: project.bootstrap_command || undefined,
+        linked_idea_id: project.linked_idea_id || undefined,
+        linked_feature_id: project.linked_feature_id || undefined,
+        plan: project.plan || undefined,
+        tasks: Array.isArray(project.tasks) && project.tasks.length > 0 ? project.tasks : undefined,
         session_count: project.sessions.length,
         sessions: project.sessions,
       }).filter(([, value]) => value !== undefined && value !== null),
@@ -150,6 +167,264 @@ function buildHostedProjectGroups(tabs) {
   );
 }
 
+function readJsonIfExists(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function readTextIfExists(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    const text = fs.readFileSync(filePath, "utf8").trim();
+    return text.length > 0 ? text : null;
+  } catch {
+    return null;
+  }
+}
+
+function resolveGitDir(projectRoot) {
+  const dotGit = path.join(projectRoot, ".git");
+  try {
+    const stat = fs.statSync(dotGit);
+    if (stat.isDirectory()) {
+      return dotGit;
+    }
+    if (stat.isFile()) {
+      const text = fs.readFileSync(dotGit, "utf8").trim();
+      const match = text.match(/^gitdir:\s*(.+)$/i);
+      if (match) {
+        const gitDir = match[1].trim();
+        return path.isAbsolute(gitDir) ? gitDir : path.resolve(projectRoot, gitDir);
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+function readProjectLink(projectRoot, cache) {
+  const normalizedRoot = normalizeOptionalString(projectRoot);
+  if (!normalizedRoot) {
+    return null;
+  }
+  const cacheKey = `link:${normalizedRoot}`;
+  if (cache.has(cacheKey)) {
+    return cache.get(cacheKey);
+  }
+
+  const gitDir = resolveGitDir(normalizedRoot);
+  const linkPath = gitDir ? path.join(gitDir, "orp", "link", "project.json") : null;
+  const link = linkPath ? readJsonIfExists(linkPath) : null;
+  const ideaId = normalizeOptionalString(link?.idea_id ?? link?.ideaId);
+  if (!ideaId) {
+    cache.set(cacheKey, null);
+    return null;
+  }
+  const frontierFeatureIds =
+    link?.frontier_feature_ids && typeof link.frontier_feature_ids === "object" && !Array.isArray(link.frontier_feature_ids)
+      ? link.frontier_feature_ids
+      : link?.frontierFeatureIds && typeof link.frontierFeatureIds === "object" && !Array.isArray(link.frontierFeatureIds)
+        ? link.frontierFeatureIds
+        : {};
+  const normalizedLink = {
+    ideaId,
+    ideaTitle: normalizeOptionalString(link?.idea_title ?? link?.ideaTitle),
+    activeFeatureId: normalizeOptionalString(
+      link?.active_feature_id ?? link?.activeFeatureId ?? link?.linked_feature_id ?? link?.linkedFeatureId,
+    ),
+    frontierFeatureIds,
+  };
+  cache.set(cacheKey, normalizedLink);
+  return normalizedLink;
+}
+
+function findFrontierVersion(stack, versionId) {
+  const versions = Array.isArray(stack?.versions) ? stack.versions : [];
+  return versions.find((version) => normalizeOptionalString(version?.id) === versionId) || null;
+}
+
+function findFrontierMilestone(stack, milestoneId) {
+  const versions = Array.isArray(stack?.versions) ? stack.versions : [];
+  for (const version of versions) {
+    const milestones = Array.isArray(version?.milestones) ? version.milestones : [];
+    const milestone = milestones.find((row) => normalizeOptionalString(row?.id) === milestoneId);
+    if (milestone) {
+      return { version, milestone };
+    }
+  }
+  return { version: null, milestone: null };
+}
+
+function findFrontierPhase(milestone, phaseId) {
+  const phases = Array.isArray(milestone?.phases) ? milestone.phases : [];
+  return phases.find((phase) => normalizeOptionalString(phase?.id) === phaseId) || null;
+}
+
+function taskStatusFromFrontierStatus(value) {
+  const text = normalizeOptionalString(value)?.toLowerCase().replace(/[-\s]+/g, "_") || "";
+  if (["complete", "completed", "done", "terminal"].includes(text)) {
+    return "done";
+  }
+  if (["active", "in_progress", "running"].includes(text)) {
+    return "in_progress";
+  }
+  if (["blocked", "stuck"].includes(text)) {
+    return "blocked";
+  }
+  if (["skipped", "canceled", "cancelled"].includes(text)) {
+    return "skipped";
+  }
+  return "todo";
+}
+
+function titleFromTas(tasText) {
+  if (!tasText) {
+    return null;
+  }
+  const line = tasText
+    .split(/\r?\n/)
+    .map((row) => row.trim())
+    .find((row) => row.startsWith("# "));
+  return line ? line.replace(/^#\s+/, "").trim() || null : null;
+}
+
+function buildFrontierPlan({ projectRoot, tasText, state, stack }) {
+  const activeVersionId = normalizeOptionalString(state?.active_version ?? stack?.current_frontier?.active_version);
+  const activeMilestoneId = normalizeOptionalString(state?.active_milestone ?? stack?.current_frontier?.active_milestone);
+  const activePhaseId = normalizeOptionalString(state?.active_phase ?? stack?.current_frontier?.active_phase);
+  const nextAction = normalizeOptionalString(state?.next_action ?? stack?.current_frontier?.next_action);
+  const version = activeVersionId ? findFrontierVersion(stack, activeVersionId) : null;
+  const { milestone } = activeMilestoneId ? findFrontierMilestone(stack, activeMilestoneId) : { milestone: null };
+  const phase = activePhaseId ? findFrontierPhase(milestone, activePhaseId) : null;
+  const tasTitle = titleFromTas(tasText);
+  const summary =
+    tasTitle ||
+    normalizeOptionalString(milestone?.label) ||
+    normalizeOptionalString(phase?.label) ||
+    normalizeOptionalString(version?.label) ||
+    nextAction;
+
+  const bodyParts = [
+    nextAction ? `Current next action: ${nextAction}` : "",
+    activeVersionId || activeMilestoneId || activePhaseId
+      ? `Active frontier: ${[activeVersionId, activeMilestoneId, activePhaseId].filter(Boolean).join(" / ")}`
+      : "",
+    tasText || "",
+  ].filter(Boolean);
+
+  if (!summary && bodyParts.length === 0) {
+    return null;
+  }
+
+  return {
+    summary: summary || null,
+    body: bodyParts.join("\n\n"),
+    source: tasText ? "orp/frontier/TAS.md" : "orp/frontier/state.json",
+  };
+}
+
+function buildFrontierTasks({ state, stack }) {
+  const activeMilestoneId = normalizeOptionalString(state?.active_milestone ?? stack?.current_frontier?.active_milestone);
+  const activePhaseId = normalizeOptionalString(state?.active_phase ?? stack?.current_frontier?.active_phase);
+  const { milestone } = activeMilestoneId ? findFrontierMilestone(stack, activeMilestoneId) : { milestone: null };
+  const phases = Array.isArray(milestone?.phases) ? milestone.phases : [];
+
+  return phases
+    .map((phase, index) => {
+      const id = normalizeOptionalString(phase?.id) || `frontier-task-${index + 1}`;
+      const status = id === activePhaseId ? "in_progress" : taskStatusFromFrontierStatus(phase?.status);
+      return {
+        id,
+        title:
+          normalizeOptionalString(phase?.label) ||
+          normalizeOptionalString(phase?.goal) ||
+          id,
+        status,
+        completed: status === "done",
+      };
+    })
+    .filter((task) => task.title);
+}
+
+function readProjectFrontierContext(projectRoot, cache) {
+  const normalizedRoot = normalizeOptionalString(projectRoot);
+  if (!normalizedRoot) {
+    return null;
+  }
+  if (cache.has(normalizedRoot)) {
+    return cache.get(normalizedRoot);
+  }
+
+  const frontierRoot = path.join(normalizedRoot, "orp", "frontier");
+  const state = readJsonIfExists(path.join(frontierRoot, "state.json"));
+  const stack = readJsonIfExists(path.join(frontierRoot, "version-stack.json"));
+  const tasText = readTextIfExists(path.join(frontierRoot, "TAS.md"));
+  const projectLink = readProjectLink(normalizedRoot, cache);
+  if (!state && !stack && !tasText && !projectLink) {
+    cache.set(normalizedRoot, null);
+    return null;
+  }
+
+  const context = {
+    plan: buildFrontierPlan({ projectRoot: normalizedRoot, tasText, state, stack }),
+    tasks: stack ? buildFrontierTasks({ state, stack }) : [],
+    link: projectLink,
+  };
+  cache.set(normalizedRoot, context);
+  return context;
+}
+
+export function enrichWorkspaceTabsWithProjectContext(tabs = []) {
+  const projectContextCache = new Map();
+  return tabs.map((tab) => {
+    const projectRoot = normalizeOptionalString(tab?.path ?? tab?.project_root ?? tab?.projectRoot);
+    const projectContext = readProjectFrontierContext(projectRoot, projectContextCache);
+    if (!projectContext) {
+      return tab;
+    }
+    const plan =
+      tab?.plan && typeof tab.plan === "object" && !Array.isArray(tab.plan)
+        ? tab.plan
+        : projectContext.plan || undefined;
+    const tasks =
+      Array.isArray(tab?.tasks) && tab.tasks.length > 0
+        ? tab.tasks
+        : Array.isArray(projectContext.tasks) && projectContext.tasks.length > 0
+          ? projectContext.tasks
+          : undefined;
+
+    return Object.fromEntries(
+      Object.entries({
+        ...tab,
+        linkedIdeaId: tab?.linkedIdeaId ?? tab?.linked_idea_id ?? projectContext.link?.ideaId,
+        linkedFeatureId: tab?.linkedFeatureId ?? tab?.linked_feature_id ?? projectContext.link?.activeFeatureId,
+        plan,
+        tasks,
+      }).filter(([, value]) => value !== undefined && value !== null),
+    );
+  });
+}
+
+export function enrichWorkspaceManifestWithProjectContext(manifest) {
+  if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
+    return manifest;
+  }
+  return {
+    ...manifest,
+    tabs: enrichWorkspaceTabsWithProjectContext(Array.isArray(manifest.tabs) ? manifest.tabs : []),
+  };
+}
+
 export function buildHostedWorkspaceState(manifest, options = {}) {
   if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
     throw new Error("workspace manifest is required to build a hosted workspace state payload");
@@ -166,11 +441,13 @@ export function buildHostedWorkspaceState(manifest, options = {}) {
   const capturedAt = normalizeOptionalString(options.capturedAt) || new Date().toISOString();
   const updatedAt = normalizeOptionalString(options.updatedAt) || capturedAt;
   const previousTabs = normalizePreviousHostedTabs(previousWorkspace);
+  const projectContextCache = new Map();
 
   const tabs = manifest.tabs.map((tab, index) => {
     const previous = matchPreviousHostedTab(tab, previousTabs);
     const title = normalizeOptionalString(tab.title) || previous?.title || null;
     const projectRoot = normalizeOptionalString(tab.path);
+    const projectContext = readProjectFrontierContext(projectRoot, projectContextCache);
     const repoLabel = previous?.repoLabel || path.basename(String(projectRoot).replace(/\/+$/, "")) || projectRoot;
     const terminalTitle = previous?.terminalTitle || title || repoLabel;
     const resume = resolveResumeMetadata({
@@ -220,8 +497,23 @@ export function buildHostedWorkspaceState(manifest, options = {}) {
         focus_summary: previous?.focusSummary || undefined,
         trajectory_summary: previous?.trajectorySummary || undefined,
         last_activity_at_utc: previous?.lastActivityAt || undefined,
-        linked_idea_id: previous?.linkedIdeaId || undefined,
-        linked_feature_id: previous?.linkedFeatureId || undefined,
+        linked_feature_id:
+          normalizeOptionalString(tab.linkedFeatureId ?? tab.linked_feature_id) ||
+          projectContext?.link?.activeFeatureId ||
+          previous?.linkedFeatureId ||
+          undefined,
+        linked_idea_id:
+          normalizeOptionalString(tab.linkedIdeaId ?? tab.linked_idea_id) ||
+          projectContext?.link?.ideaId ||
+          previous?.linkedIdeaId ||
+          undefined,
+        plan: projectContext?.plan || previous?.plan || undefined,
+        tasks:
+          Array.isArray(projectContext?.tasks) && projectContext.tasks.length > 0
+            ? projectContext.tasks
+            : Array.isArray(previous?.tasks) && previous.tasks.length > 0
+              ? previous.tasks
+              : undefined,
       }).filter(([, value]) => value !== undefined && value !== null),
     );
   });

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

@@ -41,7 +41,11 @@ export {
   runWorkspaceAddTab,
   runWorkspaceRemoveTab,
 } from "./ledger.js";
-export { buildHostedWorkspaceState } from "./hosted-state.js";
+export {
+  buildHostedWorkspaceState,
+  enrichWorkspaceManifestWithProjectContext,
+  enrichWorkspaceTabsWithProjectContext,
+} from "./hosted-state.js";
 export {
   applyWorkspaceSlotsToInventory,
   buildWorkspaceInventory,

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

@@ -10,6 +10,7 @@ import {
   resolveResumeMetadata,
   WORKSPACE_SCHEMA_VERSION,
 } from "./core-plan.js";
+import { enrichWorkspaceManifestWithProjectContext } from "./hosted-state.js";
 import { fetchIdeaPayload, loadWorkspaceSource, updateIdeaPayload } from "./orp.js";
 import { cacheManagedWorkspaceManifest } from "./registry.js";
 
@@ -198,6 +199,10 @@ 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,
         codexSessionId:
           normalizeOptionalString(entry.resumeTool) === "codex"
             ? normalizeOptionalString(entry.codexSessionId ?? entry.resumeSessionId ?? entry.sessionId) ?? undefined
@@ -250,6 +255,10 @@ 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 : [],
         })),
       }
     : {
@@ -272,6 +281,7 @@ export function buildWorkspaceSyncPreview({ source, parsed, targetIdea, workspac
             resolveResumeMetadata(entry).resumeTool === "claude" ? resolveResumeMetadata(entry).resumeSessionId : null,
         })),
       };
+  const enrichedManifest = enrichWorkspaceManifestWithProjectContext(manifest);
 
   const narrativeSourceNotes =
     source.sourceType === "workspace-file" ? targetIdea.notes || "" : source.notes || targetIdea.notes || "";
@@ -280,7 +290,7 @@ export function buildWorkspaceSyncPreview({ source, parsed, targetIdea, workspac
   });
   const nextNotes = composeWorkspaceNotes({
     narrativeNotes,
-    manifest,
+    manifest: enrichedManifest,
   });
 
   return {
@@ -289,11 +299,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,
   };
 }

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({