open-research-protocol 0.4.33 → 0.4.35

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

@@ -265,6 +265,14 @@ 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 : [];
+  const lastActivityAt = normalizeOptionalString(
+    rawTab.lastActivityAt ?? rawTab.last_activity_at_utc ?? rawTab.lastActivityAtUtc,
+  );
+  const lastSyncedAt = normalizeOptionalString(
+    rawTab.lastSyncedAt ?? rawTab.last_synced_at_utc ?? rawTab.lastSyncedAtUtc,
+  );
 
   return {
     lineNumber: index + 1,
@@ -279,6 +287,13 @@ 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,
+    lastActivityAt,
+    lastSyncedAt,
+    syncSource: normalizeOptionalString(rawTab.syncSource ?? rawTab.sync_source),
   };
 }
 
@@ -307,6 +322,29 @@ 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,
+        lastActivityAt:
+          rawSession.lastActivityAt ??
+          rawSession.last_activity_at_utc ??
+          rawSession.lastActivityAtUtc ??
+          rawProject.lastActivityAt ??
+          rawProject.last_activity_at_utc ??
+          rawProject.lastActivityAtUtc,
+        lastSyncedAt:
+          rawSession.lastSyncedAt ??
+          rawSession.last_synced_at_utc ??
+          rawSession.lastSyncedAtUtc ??
+          rawProject.lastSyncedAt ??
+          rawProject.last_synced_at_utc ??
+          rawProject.lastSyncedAtUtc,
+        syncSource: rawSession.syncSource ?? rawSession.sync_source ?? rawProject.syncSource ?? rawProject.sync_source,
       },
       sessionIndex,
     );
@@ -381,6 +419,12 @@ 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 : [],
+        lastActivityAt: normalizeOptionalString(entry.lastActivityAt ?? entry.last_activity_at_utc),
+        lastSyncedAt: normalizeOptionalString(entry.lastSyncedAt ?? entry.last_synced_at_utc),
         sessions: [],
       });
     }
@@ -389,6 +433,16 @@ 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);
+    project.lastActivityAt = project.lastActivityAt || normalizeOptionalString(entry.lastActivityAt ?? entry.last_activity_at_utc);
+    project.lastSyncedAt = project.lastSyncedAt || normalizeOptionalString(entry.lastSyncedAt ?? entry.last_synced_at_utc);
+    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(
@@ -400,6 +454,8 @@ export function buildWorkspaceProjectGroups(entries = []) {
           resumeSessionId: resume.resumeSessionId || undefined,
           codexSessionId: resume.resumeTool === "codex" ? resume.resumeSessionId || undefined : undefined,
           claudeSessionId: resume.resumeTool === "claude" ? resume.resumeSessionId || undefined : undefined,
+          lastActivityAt: normalizeOptionalString(entry.lastActivityAt ?? entry.last_activity_at_utc) || undefined,
+          lastSyncedAt: normalizeOptionalString(entry.lastSyncedAt ?? entry.last_synced_at_utc) || undefined,
         }).filter(([, value]) => value !== undefined),
       ),
     );
@@ -413,6 +469,12 @@ 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,
+        lastActivityAt: project.lastActivityAt || undefined,
+        lastSyncedAt: project.lastSyncedAt || 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";
 
@@ -71,8 +72,11 @@ function normalizePreviousHostedTabs(workspace) {
       focusSummary: normalizeOptionalString(tab.focus_summary ?? tab.focusSummary),
       trajectorySummary: normalizeOptionalString(tab.trajectory_summary ?? tab.trajectorySummary),
       lastActivityAt: normalizeOptionalString(tab.last_activity_at_utc ?? tab.lastActivityAtUtc),
+      lastSyncedAt: normalizeOptionalString(tab.last_synced_at_utc ?? tab.lastSyncedAtUtc),
       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 +115,12 @@ 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),
+        last_activity_at_utc: normalizeOptionalString(tab.last_activity_at_utc),
+        last_synced_at_utc: normalizeOptionalString(tab.last_synced_at_utc),
+        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 +128,14 @@ 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.last_activity_at_utc = project.last_activity_at_utc || normalizeOptionalString(tab.last_activity_at_utc);
+    project.last_synced_at_utc = project.last_synced_at_utc || normalizeOptionalString(tab.last_synced_at_utc);
+    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({
@@ -130,6 +148,8 @@ function buildHostedProjectGroups(tabs) {
           claude_session_id: normalizeOptionalString(tab.claude_session_id),
           status: normalizeOptionalString(tab.status),
           current_task: normalizeOptionalString(tab.current_task),
+          last_activity_at_utc: normalizeOptionalString(tab.last_activity_at_utc),
+          last_synced_at_utc: normalizeOptionalString(tab.last_synced_at_utc),
         }).filter(([, value]) => value !== undefined && value !== null),
       ),
     );
@@ -143,6 +163,12 @@ 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,
+        last_activity_at_utc: project.last_activity_at_utc || undefined,
+        last_synced_at_utc: project.last_synced_at_utc || 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 +176,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,12 +450,14 @@ 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 repoLabel = previous?.repoLabel || path.basename(String(projectRoot).replace(/\/+$/, "")) || projectRoot;
+    const projectContext = readProjectFrontierContext(projectRoot, projectContextCache);
+    const repoLabel = title || previous?.repoLabel || path.basename(String(projectRoot).replace(/\/+$/, "")) || projectRoot;
     const terminalTitle = previous?.terminalTitle || title || repoLabel;
     const resume = resolveResumeMetadata({
       resumeCommand: tab.resumeCommand,
@@ -198,6 +484,27 @@ export function buildHostedWorkspaceState(manifest, options = {}) {
       title,
       orderIndex: index,
     });
+    const plan =
+      tab.plan && typeof tab.plan === "object" && !Array.isArray(tab.plan)
+        ? tab.plan
+        : projectContext?.plan || previous?.plan || undefined;
+    const tasks =
+      Array.isArray(tab.tasks) && tab.tasks.length > 0
+        ? tab.tasks
+        : Array.isArray(projectContext?.tasks) && projectContext.tasks.length > 0
+          ? projectContext.tasks
+          : Array.isArray(previous?.tasks) && previous.tasks.length > 0
+            ? previous.tasks
+            : undefined;
+    const lastActivityAt =
+      normalizeOptionalString(tab.lastActivityAt ?? tab.last_activity_at_utc ?? tab.lastActivityAtUtc) ||
+      previous?.lastActivityAt ||
+      undefined;
+    const lastSyncedAt =
+      normalizeOptionalString(tab.lastSyncedAt ?? tab.last_synced_at_utc ?? tab.lastSyncedAtUtc) ||
+      previous?.lastSyncedAt ||
+      updatedAt ||
+      undefined;
 
     return Object.fromEntries(
       Object.entries({
@@ -219,9 +526,21 @@ export function buildHostedWorkspaceState(manifest, options = {}) {
         current_task: previous?.currentTask || undefined,
         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,
+        last_activity_at_utc: lastActivityAt,
+        last_synced_at_utc: lastSyncedAt,
+        sync_source: normalizeOptionalString(tab.syncSource ?? tab.sync_source) || 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,
+        tasks,
       }).filter(([, value]) => value !== undefined && value !== null),
     );
   });
@@ -239,6 +558,10 @@ export function buildHostedWorkspaceState(manifest, options = {}) {
       durable_backend: options.durableBackend || "manual-ledger",
     }).filter(([, value]) => value !== undefined && value !== null),
   );
+  const sourceContract =
+    options.localInventory?.contract && typeof options.localInventory.contract === "object" && !Array.isArray(options.localInventory.contract)
+      ? options.localInventory.contract
+      : undefined;
 
   const stateVersion = Math.max(1, (getHostedIntegerValue(previousState, "state_version", "stateVersion") || 0) + 1);
   const snapshotSeed = JSON.stringify({
@@ -266,6 +589,7 @@ export function buildHostedWorkspaceState(manifest, options = {}) {
       tab_count: tabs.length,
       project_count: projects.length,
       capture_context: Object.keys(captureContext).length > 0 ? captureContext : undefined,
+      source_contract: sourceContract,
       projects,
       tabs,
     }).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,
@@ -59,6 +63,7 @@ export {
   fetchIdeaPayload,
   fetchIdeasPayload,
   fetchHostedWorkspacesPayload,
+  findHostedWorkspaceByWorkspaceId,
   findHostedWorkspaceByLinkedIdea,
   findHostedWorkspaceLinkedToIdea,
   loadWorkspaceSource,
@@ -68,6 +73,11 @@ export {
   resolveWorkspaceSelectorFromCollections,
   updateIdeaPayload,
 } from "./orp.js";
+export {
+  buildLocalProjectInventory,
+  inferLocalProjectRoots,
+  mergeLocalProjectInventoryIntoManifest,
+} from "./local-inventory.js";
 export {
   cacheManagedWorkspaceManifest,
   clearWorkspaceSlot,