open-research-protocol 0.4.33 → 0.4.35

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

@@ -0,0 +1,187 @@
+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 { buildHostedWorkspaceState } from "../src/index.js";
+
+async function makeFrontierProject() {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "orp-hosted-state-frontier-"));
+  const frontierRoot = path.join(root, "orp", "frontier");
+  const linkRoot = path.join(root, ".git", "orp", "link");
+  await fs.mkdir(frontierRoot, { recursive: true });
+  await fs.mkdir(linkRoot, { recursive: true });
+  await fs.writeFile(
+    path.join(frontierRoot, "TAS.md"),
+    [
+      "# ORP TAS: Evidence-Backed Conditional Strategy Controls",
+      "",
+      "## Active Task Order",
+      "",
+      "1. Define a small replay metadata taxonomy for semantic regimes.",
+      "2. Add a metadata-quality gate.",
+    ].join("\n"),
+    "utf8",
+  );
+  await fs.writeFile(
+    path.join(frontierRoot, "state.json"),
+    JSON.stringify(
+      {
+        active_version: "v0",
+        active_milestone: "v0.2",
+        active_phase: "regime-metadata-quality",
+        next_action: "Implement replay metadata taxonomy and metadata-quality gates.",
+      },
+      null,
+      2,
+    ),
+    "utf8",
+  );
+  await fs.writeFile(
+    path.join(frontierRoot, "version-stack.json"),
+    JSON.stringify(
+      {
+        versions: [
+          {
+            id: "v0",
+            label: "Dry-run Topstep 50K lab",
+            milestones: [
+              {
+                id: "v0.2",
+                label: "Evidence-backed conditional strategy controls",
+                phases: [
+                  {
+                    id: "signal-quality-and-control-provenance",
+                    label: "Signal quality and control provenance",
+                    status: "completed",
+                  },
+                  {
+                    id: "regime-metadata-quality",
+                    label: "Regime metadata quality",
+                    status: "active",
+                  },
+                  {
+                    id: "first-regime-sample-capture",
+                    label: "First regime sample capture",
+                    status: "planned",
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+      null,
+      2,
+    ),
+    "utf8",
+  );
+  await fs.writeFile(
+    path.join(linkRoot, "project.json"),
+    JSON.stringify(
+      {
+        idea_id: "idea-123",
+        idea_title: "Canonical futures idea",
+        active_feature_id: "feature-regime-metadata-quality",
+        frontier_feature_ids: {
+          "regime-metadata-quality": "feature-regime-metadata-quality",
+        },
+        project_root: root,
+      },
+      null,
+      2,
+    ),
+    "utf8",
+  );
+  return root;
+}
+
+test("buildHostedWorkspaceState compiles local ORP frontier plan and tasks", async () => {
+  const projectRoot = await makeFrontierProject();
+  const state = buildHostedWorkspaceState({
+    version: "1",
+    workspaceId: "main-cody-1",
+    title: "main-cody-1",
+    tabs: [
+      {
+        title: "futures-prop-trading-lab",
+        path: projectRoot,
+        resumeTool: "codex",
+        resumeSessionId: "019d4f24-c8ba-78b2-a726-48b1ce9f0fe9",
+      },
+    ],
+  });
+
+  assert.equal(state.tabs.length, 1);
+  assert.equal(state.tabs[0].plan.summary, "ORP TAS: Evidence-Backed Conditional Strategy Controls");
+  assert.equal(state.tabs[0].plan.source, "orp/frontier/TAS.md");
+  assert.equal(state.tabs[0].linked_idea_id, "idea-123");
+  assert.equal(state.tabs[0].linked_feature_id, "feature-regime-metadata-quality");
+  assert.match(state.tabs[0].plan.body, /Current next action: Implement replay metadata taxonomy/);
+  assert.deepEqual(
+    state.tabs[0].tasks.map((task) => [task.id, task.status]),
+    [
+      ["signal-quality-and-control-provenance", "done"],
+      ["regime-metadata-quality", "in_progress"],
+      ["first-regime-sample-capture", "todo"],
+    ],
+  );
+  assert.equal(state.projects[0].plan.summary, "ORP TAS: Evidence-Backed Conditional Strategy Controls");
+  assert.equal(state.projects[0].tasks.length, 3);
+  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: [