open-research-protocol 0.4.34 → 0.4.36

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,12 +10,22 @@ import {
   resolveResumeMetadata,
   WORKSPACE_SCHEMA_VERSION,
 } from "./core-plan.js";
-import { enrichWorkspaceManifestWithProjectContext } from "./hosted-state.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
@@ -129,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") {
@@ -203,6 +240,11 @@ function serializeWorkspaceManifest(manifest) {
         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
@@ -237,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
     ? {
@@ -259,6 +405,9 @@ export function buildWorkspaceSyncPreview({ source, parsed, targetIdea, workspac
           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,
         })),
       }
     : {
@@ -279,9 +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 enrichedManifest = enrichWorkspaceManifestWithProjectContext(manifest);
+  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 || "";
@@ -316,12 +476,25 @@ function summarizeSyncPreview(preview) {
     `  parse mode: ${preview.parseMode}`,
     `  workspace id: ${preview.workspaceId}`,
     `  tabs: ${preview.tabs.length}`,
-    `  stored notes: ${preview.nextNotesLength} chars`,
   ];
+  if (preview.hostedWorkspaceId) {
+    lines.push(`  compatibility notes: ${preview.nextNotesLength} chars (not written when hosted push succeeds)`);
+  } else {
+    lines.push(`  stored notes: ${preview.nextNotesLength} chars`);
+  }
+  if (preview.compactedIdeaNotes && !preview.hostedWorkspaceId) {
+    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");
 }
 
@@ -340,10 +513,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(
@@ -366,23 +541,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/hosted-state.test.js

@@ -132,3 +132,56 @@ test("buildHostedWorkspaceState compiles local ORP frontier plan and tasks", asy
   assert.equal(state.projects[0].linked_idea_id, "idea-123");
   assert.equal(state.projects[0].linked_feature_id, "feature-regime-metadata-quality");
 });
+
+test("buildHostedWorkspaceState preserves manifest plan tasks and activity timestamps", () => {
+  const state = buildHostedWorkspaceState(
+    {
+      version: "1",
+      workspaceId: "main-cody-1",
+      title: "main-cody-1",
+      tabs: [
+        {
+          title: "tailnet-app",
+          path: "/Volumes/Code_2TB/code/tailnet-app",
+          resumeTool: "codex",
+          resumeSessionId: "019dcd50-111d-7451-bd01-dbc21336c679",
+          linkedIdeaId: "idea-tailnet",
+          linkedFeatureId: "feature-tailnet",
+          plan: {
+            summary: "Ship Tailnet App workspace sync",
+            body: "Keep the hosted workspace aligned with local project inventory.",
+          },
+          tasks: [
+            {
+              id: "sync-contract",
+              title: "Define sync contract",
+              status: "in_progress",
+            },
+          ],
+          lastActivityAt: "2026-04-30T02:59:15.000Z",
+          lastSyncedAt: "2026-04-30T12:00:00.000Z",
+          syncSource: "orp-project-startup",
+        },
+      ],
+    },
+    {
+      updatedAt: "2026-04-30T12:30:00.000Z",
+      localInventory: {
+        contract: {
+          source_of_truth: "orp-workspace-ledger",
+        },
+      },
+    },
+  );
+
+  assert.equal(state.tabs[0].plan.summary, "Ship Tailnet App workspace sync");
+  assert.equal(state.tabs[0].tasks[0].id, "sync-contract");
+  assert.equal(state.tabs[0].linked_idea_id, "idea-tailnet");
+  assert.equal(state.tabs[0].linked_feature_id, "feature-tailnet");
+  assert.equal(state.tabs[0].last_activity_at_utc, "2026-04-30T02:59:15.000Z");
+  assert.equal(state.tabs[0].last_synced_at_utc, "2026-04-30T12:00:00.000Z");
+  assert.equal(state.tabs[0].sync_source, "orp-project-startup");
+  assert.equal(state.projects[0].last_activity_at_utc, "2026-04-30T02:59:15.000Z");
+  assert.equal(state.projects[0].sessions[0].last_synced_at_utc, "2026-04-30T12:00:00.000Z");
+  assert.equal(state.source_contract.source_of_truth, "orp-workspace-ledger");
+});

package/packages/orp-workspace-launcher/test/local-inventory.test.js

@@ -0,0 +1,126 @@
+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 { mergeLocalProjectInventoryIntoManifest } from "../src/index.js";
+
+async function makeTempDir() {
+  return fs.mkdtemp(path.join(os.tmpdir(), "orp-local-inventory-"));
+}
+
+async function writeJson(filePath, payload) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+
+test("mergeLocalProjectInventoryIntoManifest reconciles ORP startup, Clawdad, and known Codex sessions", async () => {
+  const root = await makeTempDir();
+  const codexHome = path.join(root, "codex-home");
+  const clawdadStatePath = path.join(root, "clawdad", "state.json");
+  const existingPath = path.join(root, "existing");
+  const tailnetPath = path.join(root, "tailnet-app");
+  const financialPath = path.join(root, "financial-stack");
+
+  await fs.mkdir(existingPath, { recursive: true });
+  await writeJson(path.join(tailnetPath, "orp", "state.json"), {
+    startup: {
+      updated_at_utc: "2026-04-30T02:59:15Z",
+      workspace: {
+        requested: true,
+        workspace: "main",
+        path: tailnetPath,
+        result: {
+          manifest: {
+            version: "1",
+            workspaceId: "main",
+            title: "main",
+            tabs: [
+              {
+                title: "financial-stack",
+                path: financialPath,
+                resumeTool: "codex",
+                resumeSessionId: "019dc348-ce52-7f52-8ac8-0200a9bf946a",
+              },
+            ],
+          },
+          tab: {
+            title: "Tailnet App",
+            path: tailnetPath,
+            bootstrapCommand: "npm test",
+            resumeTool: "codex",
+            resumeSessionId: "019dcd50-111d-7451-bd01-dbc21336c679",
+          },
+        },
+      },
+    },
+  });
+  await writeJson(clawdadStatePath, {
+    projects: {
+      [financialPath]: {
+        status: "completed",
+        last_dispatch: "2026-04-25T20:47:50Z",
+        last_response: "2026-04-25T20:49:37Z",
+        registered_at: "2026-04-25T20:11:21.625Z",
+        sessions: {
+          "019dc348-ce52-7f52-8ac8-0200a9bf946a": {
+            slug: "financial-stack",
+            provider: "codex",
+            quarantined: "true",
+          },
+          "019dc644-d31d-78e1-a3ed-8575aead1c96": {
+            slug: "financial-stack",
+            provider: "codex",
+            tracked_at: "2026-04-25T20:11:21.625Z",
+          },
+        },
+        quarantined_sessions: {
+          "019dc348-ce52-7f52-8ac8-0200a9bf946a": true,
+        },
+      },
+    },
+  });
+  const codexSessionPath = path.join(codexHome, "sessions", "2026", "04", "30", "rollout-existing.jsonl");
+  await fs.mkdir(path.dirname(codexSessionPath), { recursive: true });
+  await fs.writeFile(codexSessionPath, `${JSON.stringify({
+    timestamp: "2026-04-30T12:00:00.000Z",
+    type: "session_meta",
+    payload: {
+      id: "019df000-1111-7222-8333-444455556666",
+      cwd: existingPath,
+      timestamp: "2026-04-30T12:00:00.000Z",
+    },
+  })}\n`, "utf8");
+
+  const merged = await mergeLocalProjectInventoryIntoManifest(
+    {
+      version: "1",
+      workspaceId: "main",
+      title: "main",
+      tabs: [
+        {
+          title: "existing",
+          path: existingPath,
+          resumeTool: "codex",
+          resumeSessionId: "019d0000-1111-7222-8333-444455556666",
+        },
+      ],
+    },
+    {
+      localProjectRoots: [root],
+      clawdadStatePath,
+      codexHome,
+      workspaceSelector: "main",
+      codexScanDays: 30,
+    },
+  );
+
+  const byPath = new Map(merged.manifest.tabs.map((tab) => [tab.path, tab]));
+  assert.equal(byPath.get(existingPath)?.resumeSessionId, "019df000-1111-7222-8333-444455556666");
+  assert.equal(byPath.get(tailnetPath)?.bootstrapCommand, "npm test");
+  assert.equal(byPath.get(tailnetPath)?.resumeSessionId, "019dcd50-111d-7451-bd01-dbc21336c679");
+  assert.equal(byPath.get(financialPath)?.resumeSessionId, "019dc644-d31d-78e1-a3ed-8575aead1c96");
+  assert.equal([...byPath.values()].some((tab) => tab.resumeSessionId === "019dc348-ce52-7f52-8ac8-0200a9bf946a"), false);
+  assert.equal(merged.inventory.projectCount, 3);
+});

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

@@ -6,6 +6,7 @@ import path from "node:path";
 
 import {
   chooseImplicitMainCandidate,
+  findHostedWorkspaceByWorkspaceId,
   loadWorkspaceSource,
   resolveWorkspaceSelectorFromCollections,
   resolveWorkspaceWatchTargets,
@@ -44,6 +45,24 @@ test("resolveWorkspaceSelectorFromCollections matches hosted ideas by saved work
   assert.equal(byTitleSlug?.title, "Main Cody 1");
 });
 
+test("findHostedWorkspaceByWorkspaceId matches hosted workspace records by durable id", () => {
+  const workspace = findHostedWorkspaceByWorkspaceId(
+    [
+      {
+        workspace_id: "focused-items",
+        title: "focused-items",
+      },
+      {
+        workspace_id: "captured-iterm-window-20260401t032225z",
+        title: "main-workspace",
+      },
+    ],
+    "captured-iterm-window-20260401t032225z",
+  );
+
+  assert.equal(workspace?.title, "main-workspace");
+});
+
 test("resolveWorkspaceSelectorFromCollections can match local tracked workspaces by title", () => {
   const resolved = resolveWorkspaceSelectorFromCollections("ORP Main", {
     localWorkspaces: [