open-research-protocol 0.4.33 → 0.4.34

package/CHANGELOG.md

@@ -6,6 +6,30 @@ There was no prior in-repo changelog file, so the first formal entry starts
 with the currently shipped `v0.4.4` release and summarizes the full release
 delta reflected in this repo.
 
+## v0.4.34 - 2026-04-30
+
+This release connects ORP frontier plans to hosted ORP ideas/features and lets
+workspace snapshots carry canonical project references instead of stale copied
+task text.
+
+### Added
+
+- Added `orp frontier sync-idea` to create or update a hosted ORP idea from a
+  repo's frontier TAS/current phase, then sync milestone phases as hosted
+  feature tasks with completion state.
+- Added project-link metadata for active frontier feature ids so
+  `.git/orp/link/project.json` can map local frontier phases back to hosted
+  ORP feature records.
+- Added workspace enrichment for linked ORP projects, including compact
+  `linkedIdeaId` / `linkedFeatureId` references and local frontier plan/task
+  summaries for workspace sync previews.
+
+### Changed
+
+- Workspace sync now preserves linked idea/feature references in structured
+  workspace manifests so the hosted web app can prefer canonical ORP
+  idea/features for plan and task rendering.
+
 ## v0.4.33 - 2026-04-30
 
 This release teaches ORP to manage Codex's global instruction and startup hook

package/cli/orp.py

@@ -4941,9 +4941,31 @@ def _build_remote_feature_body(
         body["superStarred"] = True
     if getattr(args, "visibility", None) is not None:
         body["visibility"] = str(getattr(args, "visibility", "")).strip()
+    completed = bool(getattr(args, "completed", False))
+    incomplete = bool(getattr(args, "incomplete", False))
+    if completed and incomplete:
+        raise RuntimeError("Use only one of --completed or --incomplete.")
+    if completed or incomplete:
+        body["completed"] = completed
     return body
 
 
+def _feature_body_has_metadata_update(body: dict[str, Any]) -> bool:
+    return any(
+        key in body
+        for key in (
+            "title",
+            "notes",
+            "detail",
+            "detailLabel",
+            "details",
+            "starred",
+            "superStarred",
+            "visibility",
+        )
+    )
+
+
 def _resolve_codex_bin(args: argparse.Namespace) -> str:
     explicit = str(getattr(args, "codex_bin", "")).strip()
     if explicit:
@@ -7753,6 +7775,7 @@ def _normalize_link_project_payload(
         "world_name": ["world_name", "worldName", "name"],
         "github_url": ["github_url", "githubUrl"],
         "linked_email": ["linked_email", "linkedEmail"],
+        "active_feature_id": ["active_feature_id", "activeFeatureId", "linked_feature_id", "linkedFeatureId"],
         "notes": ["notes"],
     }.items():
         value = ""
@@ -7762,6 +7785,15 @@ def _normalize_link_project_payload(
                 break
         if value:
             payload[key] = value
+    frontier_feature_ids = raw.get("frontier_feature_ids", raw.get("frontierFeatureIds"))
+    if isinstance(frontier_feature_ids, dict):
+        normalized_feature_ids = {
+            str(key).strip(): str(value).strip()
+            for key, value in frontier_feature_ids.items()
+            if str(key).strip() and str(value).strip()
+        }
+        if normalized_feature_ids:
+            payload["frontier_feature_ids"] = normalized_feature_ids
     payload["source"] = source
     return payload
 
@@ -13276,6 +13308,7 @@ def _about_payload() -> dict[str, Any]:
                     ["frontier", "add-phase"],
                     ["frontier", "set-live"],
                     ["frontier", "render"],
+                    ["frontier", "sync-idea"],
                     ["frontier", "doctor"],
                 ],
             },
@@ -13460,6 +13493,7 @@ def _about_payload() -> dict[str, Any]:
             {"name": "frontier_add_phase", "path": ["frontier", "add-phase"], "json_output": True},
             {"name": "frontier_set_live", "path": ["frontier", "set-live"], "json_output": True},
             {"name": "frontier_render", "path": ["frontier", "render"], "json_output": True},
+            {"name": "frontier_sync_idea", "path": ["frontier", "sync-idea"], "json_output": True},
             {"name": "frontier_doctor", "path": ["frontier", "doctor"], "json_output": True},
             {"name": "branch_start", "path": ["branch", "start"], "json_output": True},
             {"name": "checkpoint_create", "path": ["checkpoint", "create"], "json_output": True},
@@ -16937,6 +16971,305 @@ def cmd_frontier_render(args: argparse.Namespace) -> int:
     return 0
 
 
+FRONTIER_FEATURE_MARKER_PATTERN = re.compile(r"<!--\s*ORP:FRONTIER_PHASE:([^>\s]+)\s*-->")
+
+
+def _frontier_tas_text(repo_root: Path) -> str:
+    path = _frontier_paths(repo_root)["root"] / "TAS.md"
+    if not path.exists():
+        return ""
+    return _read_text(path).strip()
+
+
+def _frontier_tas_title(text: str) -> str:
+    for line in str(text or "").splitlines():
+        stripped = line.strip()
+        if stripped.startswith("# "):
+            return stripped[2:].strip()
+    return ""
+
+
+def _frontier_plan_notes(repo_root: Path, stack: dict[str, Any], state: dict[str, Any]) -> tuple[str, str]:
+    tas_text = _frontier_tas_text(repo_root)
+    title = (
+        _frontier_tas_title(tas_text)
+        or str(stack.get("label", "")).strip()
+        or str(stack.get("program_id", "")).strip()
+        or repo_root.name
+    )
+    active_parts = [
+        str(state.get("active_version", "")).strip(),
+        str(state.get("active_milestone", "")).strip(),
+        str(state.get("active_phase", "")).strip(),
+    ]
+    body_parts = [
+        f"Current next action: {str(state.get('next_action', '')).strip()}" if str(state.get("next_action", "")).strip() else "",
+        f"Active frontier: {' / '.join([part for part in active_parts if part])}" if any(active_parts) else "",
+        tas_text,
+    ]
+    return title, "\n\n".join(part for part in body_parts if part).strip()
+
+
+def _frontier_phase_completed(status: str) -> bool:
+    return _frontier_status(status, default="planned") in {"complete", "completed", "done", "terminal"}
+
+
+def _frontier_phase_tasks(stack: dict[str, Any], state: dict[str, Any]) -> list[dict[str, Any]]:
+    active_milestone_id = str(state.get("active_milestone", "") or stack.get("current_frontier", {}).get("active_milestone", "")).strip()
+    active_phase_id = str(state.get("active_phase", "") or stack.get("current_frontier", {}).get("active_phase", "")).strip()
+    _, milestone = _frontier_find_milestone(stack, active_milestone_id) if active_milestone_id else (None, None)
+    phases = milestone.get("phases") if isinstance(milestone, dict) else []
+    rows: list[dict[str, Any]] = []
+    for index, phase in enumerate(phases if isinstance(phases, list) else []):
+        if not isinstance(phase, dict):
+            continue
+        phase_id = str(phase.get("id", "")).strip() or f"frontier-phase-{index + 1}"
+        status = _frontier_status(phase.get("status"), default="planned")
+        rows.append(
+            {
+                "phase_id": phase_id,
+                "title": str(phase.get("label", "")).strip() or str(phase.get("goal", "")).strip() or phase_id,
+                "status": "active" if phase_id == active_phase_id else status,
+                "completed": _frontier_phase_completed(status),
+                "active": phase_id == active_phase_id,
+                "phase": phase,
+            }
+        )
+    return rows
+
+
+def _frontier_feature_notes(task: dict[str, Any]) -> str:
+    phase = task.get("phase") if isinstance(task.get("phase"), dict) else {}
+    phase_id = str(task.get("phase_id", "")).strip()
+    lines = [
+        f"<!-- ORP:FRONTIER_PHASE:{phase_id} -->",
+        f"ORP frontier phase id: {phase_id}",
+        f"Status: {str(task.get('status', '')).strip() or 'planned'}",
+    ]
+    goal = str(phase.get("goal", "")).strip()
+    if goal:
+        lines.extend(["", "Goal:", goal])
+    for label, key in [
+        ("Requirements", "requirements"),
+        ("Success criteria", "success_criteria"),
+        ("Plan", "plans"),
+    ]:
+        values = _coerce_string_list(phase.get(key))
+        if values:
+            lines.extend(["", f"{label}:"])
+            lines.extend([f"- {value}" for value in values])
+    return "\n".join(lines).strip()
+
+
+def _feature_text_for_matching(feature: dict[str, Any]) -> str:
+    parts = [
+        str(feature.get("title", "") or ""),
+        str(feature.get("notes", "") or ""),
+        str(feature.get("detail", "") or ""),
+    ]
+    sections = feature.get("detailSections", feature.get("details"))
+    if isinstance(sections, list):
+        for section in sections:
+            if isinstance(section, dict):
+                parts.append(str(section.get("body", "") or ""))
+                parts.append(str(section.get("detail", "") or ""))
+    return "\n".join(parts)
+
+
+def _frontier_phase_id_from_feature(feature: dict[str, Any]) -> str:
+    match = FRONTIER_FEATURE_MARKER_PATTERN.search(_feature_text_for_matching(feature))
+    return match.group(1).strip() if match else ""
+
+
+def _frontier_match_features_by_phase(features: list[dict[str, Any]]) -> dict[str, dict[str, Any]]:
+    matches: dict[str, dict[str, Any]] = {}
+    for feature in features:
+        phase_id = _frontier_phase_id_from_feature(feature)
+        if phase_id and phase_id not in matches:
+            matches[phase_id] = feature
+    return matches
+
+
+def _frontier_sync_update_idea(args: argparse.Namespace, idea_id: str, title: str, notes: str, *, dry_run: bool) -> dict[str, Any]:
+    current = _get_remote_idea(args, idea_id)
+    if dry_run:
+        return current
+    session = _require_hosted_session(args)
+    body = {
+        "title": title,
+        "notes": notes,
+    }
+    updated_at = str(current.get("updatedAt", "")).strip()
+    if updated_at:
+        body["updatedAt"] = updated_at
+    payload = _request_hosted_json(
+        base_url=_resolve_hosted_base_url(args, session),
+        path=f"/api/cli/ideas/{urlparse.quote(idea_id)}",
+        method="PATCH",
+        token=str(session.get("token", "")).strip(),
+        body=body,
+    )
+    return _normalize_remote_idea_payload(payload)["idea"]
+
+
+def _frontier_sync_create_idea(args: argparse.Namespace, title: str, notes: str, *, dry_run: bool) -> dict[str, Any]:
+    if dry_run:
+        return {"id": "", "title": title, "notes": notes}
+    session = _require_hosted_session(args)
+    payload = _request_hosted_json(
+        base_url=_resolve_hosted_base_url(args, session),
+        path="/api/cli/ideas",
+        method="POST",
+        token=str(session.get("token", "")).strip(),
+        body={"title": title, "notes": notes},
+    )
+    return _normalize_remote_idea_payload(payload)["idea"]
+
+
+def _frontier_sync_feature(
+    args: argparse.Namespace,
+    *,
+    idea_id: str,
+    task: dict[str, Any],
+    existing: dict[str, Any] | None,
+    dry_run: bool,
+) -> dict[str, Any]:
+    phase_id = str(task.get("phase_id", "")).strip()
+    body = {
+        "ideaId": idea_id,
+        "title": str(task.get("title", "")).strip(),
+        "notes": _frontier_feature_notes(task),
+        "completed": bool(task.get("completed")),
+    }
+    action = "update" if existing else "create"
+    if dry_run:
+        return {
+            "phase_id": phase_id,
+            "action": action,
+            "feature": existing or {"id": "", "ideaId": idea_id, "title": body["title"], "completed": body["completed"]},
+        }
+    session = _require_hosted_session(args)
+    if existing:
+        updated_at = str(existing.get("updatedAt", "")).strip()
+        if updated_at:
+            body["updatedAt"] = updated_at
+        payload = _request_hosted_json(
+            base_url=_resolve_hosted_base_url(args, session),
+            path=f"/api/cli/features/{urlparse.quote(str(existing.get('id', '')).strip())}",
+            method="PATCH",
+            token=str(session.get("token", "")).strip(),
+            body=body,
+        )
+    else:
+        payload = _request_hosted_json(
+            base_url=_resolve_hosted_base_url(args, session),
+            path=f"/api/cli/ideas/{urlparse.quote(idea_id)}/features",
+            method="POST",
+            token=str(session.get("token", "")).strip(),
+            body=body,
+        )
+        created = _normalize_remote_feature_payload(payload)
+        if bool(task.get("completed")) and str(created.get("id", "")).strip():
+            created = _patch_remote_feature_completion(
+                args,
+                feature_id=str(created.get("id", "")).strip(),
+                completed=True,
+            )
+            payload = {"ok": True, "feature": created}
+    return {
+        "phase_id": phase_id,
+        "action": action,
+        "feature": _normalize_remote_feature_payload(payload),
+    }
+
+
+def cmd_frontier_sync_idea(args: argparse.Namespace) -> int:
+    repo_root = Path(args.repo_root).resolve()
+    stack = _frontier_load_stack(repo_root)
+    state = _frontier_load_state(repo_root)
+    project_link = _read_link_project(repo_root)
+    requested_idea_id = str(getattr(args, "idea_id", "") or "").strip()
+    idea_id = requested_idea_id or str(project_link.get("idea_id", "")).strip()
+    title, notes = _frontier_plan_notes(repo_root, stack, state)
+    dry_run = bool(getattr(args, "dry_run", False))
+    create_idea = bool(getattr(args, "create_idea", False))
+
+    if not idea_id and not create_idea:
+        raise RuntimeError(
+            "No hosted idea is linked. Run `orp frontier sync-idea --create-idea --json`, or pass --idea-id."
+        )
+
+    idea_created = False
+    if idea_id:
+        idea = _frontier_sync_update_idea(args, idea_id, title, notes, dry_run=dry_run)
+    else:
+        idea = _frontier_sync_create_idea(args, title, notes, dry_run=dry_run)
+        idea_id = str(idea.get("id", "")).strip()
+        idea_created = True
+
+    tasks = _frontier_phase_tasks(stack, state)
+    existing_features = _list_remote_features(args, idea_id) if idea_id else []
+    features_by_phase = _frontier_match_features_by_phase(existing_features)
+    synced_features: list[dict[str, Any]] = []
+    frontier_feature_ids: dict[str, str] = {
+        str(key): str(value)
+        for key, value in (project_link.get("frontier_feature_ids") if isinstance(project_link.get("frontier_feature_ids"), dict) else {}).items()
+        if str(key).strip() and str(value).strip()
+    }
+    active_feature_id = ""
+
+    for task in tasks:
+        phase_id = str(task.get("phase_id", "")).strip()
+        existing = features_by_phase.get(phase_id)
+        synced = _frontier_sync_feature(args, idea_id=idea_id, task=task, existing=existing, dry_run=dry_run)
+        synced_features.append(synced)
+        feature_id = str(synced.get("feature", {}).get("id", "")).strip()
+        if feature_id:
+            frontier_feature_ids[phase_id] = feature_id
+        if bool(task.get("active")):
+            active_feature_id = feature_id
+
+    project_link_path = ""
+    should_link_project = not bool(getattr(args, "no_link_project", False))
+    if should_link_project and not dry_run and idea_id:
+        next_link = {
+            **project_link,
+            "idea_id": idea_id,
+            "idea_title": str(idea.get("title", "")).strip() or title,
+            "project_root": str(repo_root),
+            "active_feature_id": active_feature_id,
+            "frontier_feature_ids": frontier_feature_ids,
+            "linked_at_utc": str(project_link.get("linked_at_utc", "")).strip() or _now_utc(),
+            "source": str(project_link.get("source", "")).strip() or "cli",
+        }
+        project_link_path = _path_for_state(_write_link_project(repo_root, next_link), repo_root)
+    elif should_link_project and project_link:
+        path = _link_project_path(repo_root)
+        project_link_path = _path_for_state(path, repo_root) if path is not None else ""
+
+    result = {
+        "ok": True,
+        "dry_run": dry_run,
+        "idea_created": idea_created and not dry_run,
+        "idea": idea,
+        "tasks": tasks,
+        "features": synced_features,
+        "active_feature_id": active_feature_id,
+        "frontier_feature_ids": frontier_feature_ids,
+        "project_link_path": project_link_path,
+    }
+    if args.json_output:
+        _print_json(result)
+    else:
+        print(f"idea.id={idea_id}")
+        print(f"idea.title={str(idea.get('title', '')).strip() or title}")
+        print(f"features.synced={len(synced_features)}")
+        print(f"active_feature_id={active_feature_id}")
+        if project_link_path:
+            print(f"project.link_path={project_link_path}")
+    return 0
+
+
 def cmd_frontier_doctor(args: argparse.Namespace) -> int:
     repo_root = Path(args.repo_root).resolve()
     payload = _frontier_doctor_payload(repo_root)
@@ -25873,6 +26206,59 @@ def _normalize_remote_idea_payload(payload: dict[str, Any]) -> dict[str, Any]:
     }
 
 
+def _normalize_remote_feature_payload(payload: dict[str, Any]) -> dict[str, Any]:
+    feature = payload.get("feature") if isinstance(payload.get("feature"), dict) else payload
+    if not isinstance(feature, dict):
+        raise RuntimeError("Hosted ORP returned an invalid feature payload.")
+    return feature
+
+
+def _normalize_remote_features_payload(payload: dict[str, Any]) -> list[dict[str, Any]]:
+    features = payload.get("features")
+    if not isinstance(features, list):
+        features = payload.get("items")
+    if not isinstance(features, list):
+        idea = payload.get("idea") if isinstance(payload.get("idea"), dict) else {}
+        features = idea.get("features") if isinstance(idea.get("features"), list) else []
+    return [row for row in features if isinstance(row, dict)]
+
+
+def _patch_remote_feature_completion(
+    args: argparse.Namespace,
+    *,
+    feature_id: str,
+    completed: bool,
+) -> dict[str, Any]:
+    session = _require_hosted_session(args)
+    payload = _request_hosted_json(
+        base_url=_resolve_hosted_base_url(args, session),
+        path=f"/api/cli/features/{urlparse.quote(feature_id)}",
+        method="PATCH",
+        token=str(session.get("token", "")).strip(),
+        body={"completed": completed},
+    )
+    return _normalize_remote_feature_payload(payload)
+
+
+def _list_remote_features(args: argparse.Namespace, idea_id: str, *, fallback_to_idea: bool = True) -> list[dict[str, Any]]:
+    session = _require_hosted_session(args)
+    try:
+        payload = _request_hosted_json(
+            base_url=_resolve_hosted_base_url(args, session),
+            path=f"/api/cli/ideas/{urlparse.quote(idea_id)}/features",
+            token=str(session.get("token", "")).strip(),
+        )
+        if not isinstance(payload, dict):
+            raise RuntimeError("Hosted ORP returned an invalid features payload.")
+        return _normalize_remote_features_payload(payload)
+    except HostedApiError:
+        if not fallback_to_idea:
+            raise
+        idea = _get_remote_idea(args, idea_id)
+        features = idea.get("features") if isinstance(idea.get("features"), list) else []
+        return [row for row in features if isinstance(row, dict)]
+
+
 def _get_remote_idea(args: argparse.Namespace, idea_id: str) -> dict[str, Any]:
     session = _require_hosted_session(args)
     payload = _request_hosted_json(
@@ -26077,7 +26463,7 @@ def cmd_idea_restore(args: argparse.Namespace) -> int:
 
 def cmd_feature_list(args: argparse.Namespace) -> int:
     idea = _get_remote_idea(args, args.idea_id)
-    features = idea.get("features") if isinstance(idea.get("features"), list) else []
+    features = _list_remote_features(args, args.idea_id)
     result = {
         "idea_id": str(idea.get("id", "")).strip(),
         "idea_title": str(idea.get("title", "")).strip(),
@@ -26119,7 +26505,8 @@ def _find_feature_by_id(idea_payload: dict[str, Any], feature_id: str) -> dict[s
 
 def cmd_feature_show(args: argparse.Namespace) -> int:
     idea = _get_remote_idea(args, args.idea_id)
-    feature = _find_feature_by_id(idea, args.feature_id)
+    features = _list_remote_features(args, args.idea_id)
+    feature = _find_feature_by_id({"features": features}, args.feature_id)
     result = {
         "idea_id": str(idea.get("id", "")).strip(),
         "feature": feature,
@@ -26147,14 +26534,22 @@ def cmd_feature_add(args: argparse.Namespace) -> int:
         token=str(session.get("token", "")).strip(),
         body=body,
     )
+    feature = _normalize_remote_feature_payload(payload)
+    if "completed" in body and str(feature.get("id", "")).strip():
+        feature = _patch_remote_feature_completion(
+            args,
+            feature_id=str(feature.get("id", "")).strip(),
+            completed=bool(body["completed"]),
+        )
+        payload = {"ok": True, "feature": feature}
     if args.json_output:
         _print_json(payload)
     else:
         _print_pairs(
             [
-                ("feature.id", str(payload.get("id", "")).strip()),
-                ("feature.title", str(payload.get("title", "")).strip()),
-                ("idea.id", str(payload.get("ideaId", args.idea_id)).strip()),
+                ("feature.id", str(feature.get("id", "")).strip()),
+                ("feature.title", str(feature.get("title", "")).strip()),
+                ("idea.id", str(feature.get("ideaId", args.idea_id)).strip()),
             ]
         )
     return 0
@@ -26162,11 +26557,11 @@ def cmd_feature_add(args: argparse.Namespace) -> int:
 
 def cmd_feature_update(args: argparse.Namespace) -> int:
     session = _require_hosted_session(args)
-    idea = _get_remote_idea(args, args.idea_id)
-    current = _find_feature_by_id(idea, args.feature_id)
+    features = _list_remote_features(args, args.idea_id)
+    current = _find_feature_by_id({"features": features}, args.feature_id)
     body = _build_remote_feature_body(args, args.idea_id, current)
     updated_at = str(current.get("updatedAt", "")).strip()
-    if updated_at:
+    if updated_at and _feature_body_has_metadata_update(body):
         body["updatedAt"] = updated_at
     payload = _request_hosted_json(
         base_url=_resolve_hosted_base_url(args, session),
@@ -26175,14 +26570,15 @@ def cmd_feature_update(args: argparse.Namespace) -> int:
         token=str(session.get("token", "")).strip(),
         body=body,
     )
+    feature = _normalize_remote_feature_payload(payload)
     if args.json_output:
         _print_json(payload)
     else:
         _print_pairs(
             [
-                ("feature.id", str(payload.get("id", "")).strip()),
-                ("feature.title", str(payload.get("title", "")).strip()),
-                ("feature.updated_at", str(payload.get("updatedAt", "")).strip()),
+                ("feature.id", str(feature.get("id", "")).strip()),
+                ("feature.title", str(feature.get("title", "")).strip()),
+                ("feature.updated_at", str(feature.get("updatedAt", "")).strip()),
             ]
         )
     return 0
@@ -28398,6 +28794,9 @@ def build_parser() -> argparse.ArgumentParser:
             default=None,
             help="Feature visibility override when supported by the hosted workspace",
         )
+        completion_group = parser.add_mutually_exclusive_group()
+        completion_group.add_argument("--completed", action="store_true", help="Mark feature as completed")
+        completion_group.add_argument("--incomplete", action="store_true", help="Mark feature as not completed")
 
     s_home = sub.add_parser(
         "home",
@@ -30980,6 +31379,26 @@ def build_parser() -> argparse.ArgumentParser:
     add_json_flag(s_frontier_render)
     s_frontier_render.set_defaults(func=cmd_frontier_render, json_output=False)
 
+    s_frontier_sync_idea = frontier_sub.add_parser(
+        "sync-idea",
+        help="Sync local frontier plan and phase tasks to a hosted ORP idea/features",
+    )
+    s_frontier_sync_idea.add_argument("--idea-id", default="", help="Hosted idea id; defaults to the local project link")
+    s_frontier_sync_idea.add_argument(
+        "--create-idea",
+        action="store_true",
+        help="Create a hosted idea when the project is not already linked",
+    )
+    s_frontier_sync_idea.add_argument(
+        "--no-link-project",
+        action="store_true",
+        help="Do not update the local project link with the synced idea/feature ids",
+    )
+    s_frontier_sync_idea.add_argument("--dry-run", action="store_true", help="Preview hosted changes without writing")
+    add_base_url_flag(s_frontier_sync_idea)
+    add_json_flag(s_frontier_sync_idea)
+    s_frontier_sync_idea.set_defaults(func=cmd_frontier_sync_idea, json_output=False)
+
     s_frontier_doctor = frontier_sub.add_parser(
         "doctor",
         help="Validate frontier consistency and optionally re-render views",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-research-protocol",
-  "version": "0.4.33",
+  "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({

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

@@ -0,0 +1,134 @@
+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");
+});