open-research-protocol 0.4.21 → 0.4.23

package/AGENT_INTEGRATION.md

@@ -48,8 +48,12 @@ If the agent only remembers one ORP loop, it should be this:
    ```bash
    orp frontier state --json
    ```
-5. do the next honest move
-6. checkpoint it honestly
+5. if the work feels confusing or too large, break it down before moving
+   ```bash
+   orp mode breakdown granular-breakdown --json
+   ```
+6. do the next honest move
+7. checkpoint it honestly
    ```bash
    orp checkpoint create -m "checkpoint note" --json
    ```
@@ -60,6 +64,7 @@ That is the ORP rhythm in one line:
 - inspect repo safety
 - resolve access
 - inspect context
+- break down complexity when comprehension would help
 - do the work
 - checkpoint it honestly
 

package/README.md

@@ -122,9 +122,11 @@ orp report summary
 orp frontier state
 orp schedule list
 orp mode nudge sleek-minimal-progressive
+orp mode breakdown granular-breakdown
+orp mode nudge granular-breakdown
 ```
 
-That sequence covers discovery, agent-guide alignment, workspace recovery, agenda refresh, secret resolution, governance, artifacts, planning, automation, and perspective-shift support.
+That sequence covers discovery, agent-guide alignment, workspace recovery, agenda refresh, secret resolution, governance, artifacts, planning, automation, perspective-shift support, and intentional breakdown when the work needs more granular comprehension. Use `mode breakdown` for the full broad-to-atomic ladder; use `mode nudge` when you only need a short reminder card.
 
 The shorter rule is:
 
@@ -403,6 +405,9 @@ orp about --json
 orp mode list --json
 orp mode show sleek-minimal-progressive --json
 orp mode nudge sleek-minimal-progressive --json
+orp mode show granular-breakdown --json
+orp mode breakdown granular-breakdown --json
+orp mode nudge granular-breakdown --json
 orp update --json
 orp maintenance status --json
 ```
@@ -427,6 +432,7 @@ orp workspace create mac-main --machine-label "Mac Studio"
 orp workspace list
 orp workspace tabs main
 orp workspace add-tab main --path /absolute/path/to/project --remote-url git@github.com:org/project.git --bootstrap-command "npm install" --resume-command "codex resume <id>"
+orp workspace add-tab main --path /absolute/path/to/project --title "second active thread" --resume-tool claude --resume-session-id <id> --append
 orp workspace remove-tab main --path /absolute/path/to/project
 orp workspace sync main
 orp secrets list --json

package/cli/orp.py

@@ -286,7 +286,7 @@ YOUTUBE_ANDROID_CLIENT_VERSION = "20.10.38"
 YOUTUBE_ANDROID_USER_AGENT = (
     f"com.google.android.youtube/{YOUTUBE_ANDROID_CLIENT_VERSION} (Linux; U; Android 14)"
 )
-AGENT_MODE_REGISTRY_VERSION = "1.0.0"
+AGENT_MODE_REGISTRY_VERSION = "1.2.0"
 AGENT_MODES: list[dict[str, Any]] = [
     {
         "id": "sleek-minimal-progressive",
@@ -597,6 +597,175 @@ AGENT_MODES: list[dict[str, Any]] = [
             },
         ],
     },
+    {
+        "id": "granular-breakdown",
+        "aliases": ["breakdown", "breakdown-mode", "stepwise-breakdown", "gb"],
+        "label": "Granular Breakdown",
+        "summary": "An optional comprehension overlay for breaking complex work into smaller pieces, ordered dependencies, and concrete next moves.",
+        "operator_reminder": "Use this when the work is hard to hold in your head, when the user sounds confused, or when a plan needs more intentional granularity before execution.",
+        "activation_phrase": "Break it down until it can move.",
+        "invocation_style": "Optional but core-loop friendly. Call it whenever comprehension, onboarding, or safe execution would improve with smaller steps.",
+        "when_to_use": [
+            "When a project, error, or plan feels too large to reason about at once.",
+            "When the user asks what something means or seems unsure about the workflow.",
+            "When a change has several dependencies that should be sequenced before implementation.",
+            "When a handoff needs to be understandable to a future agent or collaborator.",
+        ],
+        "perspective_shifts": [
+            "Turn the blob into named parts before debating solutions.",
+            "Separate current state, desired state, blockers, and next action.",
+            "Order the parts by dependency, risk, and user comprehension.",
+            "Prefer a small verified loop over a large impressive explanation.",
+        ],
+        "principles": [
+            "Granularity is a service to comprehension, not a performance of detail.",
+            "Every breakdown should create a next move, not just a longer list.",
+            "Name assumptions before building on top of them.",
+            "Compress again after decomposing so the user gets clarity, not clutter.",
+        ],
+        "ritual": [
+            "Name the whole problem in one sentence.",
+            "Split it into current state, desired state, and missing bridge.",
+            "List the smallest meaningful steps in dependency order.",
+            "Identify the next test or confirmation that proves movement.",
+        ],
+        "questions": [
+            "What are the actual pieces here?",
+            "Which piece needs to be understood first for the rest to make sense?",
+            "What is blocking action versus only blocking confidence?",
+            "What is the smallest safe step that would reduce ambiguity?",
+            "After the breakdown, what can we compress back into one clear sentence?",
+        ],
+        "anti_patterns": [
+            "Making a breakdown so exhaustive that it becomes another wall of confusion.",
+            "Skipping the dependency order and calling a pile of bullets a plan.",
+            "Explaining implementation details before naming the user's actual question.",
+            "Using granularity to delay the next concrete move.",
+        ],
+        "micro_loop": [
+            "Name the whole confusing thing in one plain sentence.",
+            "Split it into current state, desired state, missing bridge, and dependency order.",
+            "Choose one small verification that reduces ambiguity, then compress the result back down.",
+        ],
+        "breakdown_sequence": [
+            {
+                "level_id": "L0_whole_frame",
+                "title": "Whole Frame",
+                "purpose": "Start broad enough that the user and future agent know what object is being decomposed.",
+                "prompt": "What is the broad claim, request, or confusion in one plain sentence?",
+                "output": "One sentence that names the top-level object without trying to solve it yet.",
+                "completion_check": "A future reader can tell what cathedral we are talking about before seeing any stones.",
+            },
+            {
+                "level_id": "L1_boundary",
+                "title": "Boundary",
+                "purpose": "Separate proof, implementation, and discovery so the breakdown does not overclaim.",
+                "prompt": "What is the exact desired state, and what is explicitly not being claimed yet?",
+                "output": "A narrowed north star plus falsifier, exception, or overclaim boundaries.",
+                "completion_check": "The target is smaller than the dream and honest about what remains unproved or undone.",
+            },
+            {
+                "level_id": "L2_major_lanes",
+                "title": "Major Lanes",
+                "purpose": "Break the top-level target into a small number of non-overlapping lanes.",
+                "prompt": "Which 3-7 lanes or phases cover the work without overlapping too much?",
+                "output": "Named lanes such as counting language, compatibility language, graph reduction, matching bounds, margin lift, finite closure.",
+                "completion_check": "Every important concern has a lane, and no lane is pretending to be the whole proof or project.",
+            },
+            {
+                "level_id": "L3_subclaims",
+                "title": "Subclaims",
+                "purpose": "Turn each lane into named obligations that can be owned, proved, tested, or handed off.",
+                "prompt": "What smaller claims, tasks, or lemmas make each lane true?",
+                "output": "Task IDs with statements, hypotheses, dependencies, and proof or work type.",
+                "completion_check": "Each subclaim is small enough to discuss independently and large enough to matter.",
+            },
+            {
+                "level_id": "L4_atomic_obligations",
+                "title": "Atomic Obligations",
+                "purpose": "Descend until each item is concrete enough to verify independently.",
+                "prompt": "Can each subclaim be split until it is either a definition check, counting identity, graph identity, finite check, data check, API check, or implementation step?",
+                "output": "Sub-sub-lemmas or atomic tasks with a falsifier boundary for each.",
+                "completion_check": "Every atomic item can be proved, computed, tested, or falsified without needing the whole plan in memory.",
+            },
+            {
+                "level_id": "L5_dependency_ladder",
+                "title": "Dependency Ladder",
+                "purpose": "Order the atomic pieces by prerequisite, risk, and comprehension value.",
+                "prompt": "What has to be true before the next rung can safely happen?",
+                "output": "A dependency-ordered ladder with blockers, ready steps, and downstream unlocks.",
+                "completion_check": "The first few moves are ordered for real dependency reasons, not just narrative convenience.",
+            },
+            {
+                "level_id": "L6_active_target",
+                "title": "Active Target",
+                "purpose": "Choose the first actionable rung and the current target theorem, task, or patch.",
+                "prompt": "What is the first actionable rung, what is the current target rung, and why is it the best next place to work?",
+                "output": "Current packet, first actionable step, target step, and why this is the next best move.",
+                "completion_check": "The next move is obvious enough that an agent can start without re-deriving the full breakdown.",
+            },
+            {
+                "level_id": "L7_durable_checklist",
+                "title": "Durable Checklist",
+                "purpose": "Promote important breakdowns out of chat memory and into a referenceable artifact.",
+                "prompt": "Where does this breakdown live so future agents can update it without depending on chat memory?",
+                "output": "A markdown checklist plus an optional machine-readable JSON checklist with statuses, dependencies, source artifacts, and falsifier boundaries.",
+                "completion_check": "The repo has a checklist that can move steps from todo to next to done without losing context.",
+            },
+            {
+                "level_id": "L8_compress_and_continue",
+                "title": "Compress And Continue",
+                "purpose": "End simpler than we began by turning the full ladder back into the next honest move.",
+                "prompt": "After decomposing the work, what is the shortest useful summary and the next verification?",
+                "output": "A compact summary, the active target, and one verification command, artifact, or proof check.",
+                "completion_check": "The user gets clarity and momentum, not just a larger pile of scaffolding.",
+            },
+        ],
+        "durable_artifact_rule": "If the breakdown becomes operationally important, write it to a durable checklist artifact with step IDs, dependencies, statuses, source artifacts, falsifier boundaries, and the first active target.",
+        "breakdown_output_contract": [
+            "Broad Frame",
+            "Boundary",
+            "Major Lanes",
+            "Subclaims",
+            "Atomic Obligations",
+            "Dependency Ladder",
+            "Active Target",
+            "Durable Checklist",
+            "Next Verification",
+        ],
+        "nudge_cards": [
+            {
+                "title": "Name The Blob",
+                "prompt": "Write the whole confusing thing as one sentence, then split it into three named parts.",
+                "twist": "If a part cannot be named plainly, it is not understood yet.",
+                "release": "A named part is easier to move than an unnamed worry.",
+            },
+            {
+                "title": "Current / Desired / Bridge",
+                "prompt": "Separate current state, desired state, and the missing bridge before proposing the fix.",
+                "twist": "Do not let the desired state masquerade as the plan.",
+                "release": "The bridge is where the real work usually lives.",
+            },
+            {
+                "title": "Dependency Ladder",
+                "prompt": "Order the next steps by what must be true before the following step can safely happen.",
+                "twist": "Put user comprehension on the ladder, not only code dependencies.",
+                "release": "A good ladder makes the climb feel obvious.",
+            },
+            {
+                "title": "Tiny Verified Loop",
+                "prompt": "Choose one small action and one verification that would reduce ambiguity within the next pass.",
+                "twist": "The step should be small enough to finish, but real enough to matter.",
+                "release": "Confidence compounds through verified movement.",
+            },
+            {
+                "title": "Explain Then Compress",
+                "prompt": "Break the topic down in detail, then compress the result into the shortest useful summary.",
+                "twist": "Do not leave the user with the scaffolding if the building is now clear.",
+                "release": "The best breakdown ends simpler than it began.",
+            },
+        ],
+    },
 ]
 
 
@@ -641,6 +810,7 @@ def _agent_mode_public_payload(mode: dict[str, Any]) -> dict[str, Any]:
         "questions": [str(row).strip() for row in mode.get("questions", []) if str(row).strip()],
         "anti_patterns": [str(row).strip() for row in mode.get("anti_patterns", []) if str(row).strip()],
         "nudge_card_count": len(mode.get("nudge_cards", [])) if isinstance(mode.get("nudge_cards"), list) else 0,
+        "breakdown_sequence_count": len(mode.get("breakdown_sequence", [])) if isinstance(mode.get("breakdown_sequence"), list) else 0,
     }
 
 
@@ -659,6 +829,13 @@ def _agent_mode_nudge(mode: dict[str, Any], *, seed: str = "") -> dict[str, Any]
     digest = hashlib.sha256(f"{mode['id']}::{effective_seed}".encode("utf-8")).hexdigest()
     index = int(digest[:8], 16) % len(cards)
     card = cards[index]
+    micro_loop = mode.get("micro_loop", [])
+    if not isinstance(micro_loop, list) or not micro_loop:
+        micro_loop = [
+            "Choose the right lens first: deeper, higher, wider, or rotated.",
+            "Make one pass sleeker by removing friction and generic weight.",
+            "Make one pass playful or progressive by trying one meaningful shift in angle.",
+        ]
     return {
         "mode": _agent_mode_public_payload(mode),
         "seed": effective_seed,
@@ -669,11 +846,57 @@ def _agent_mode_nudge(mode: dict[str, Any], *, seed: str = "") -> dict[str, Any]
             "twist": str(card.get("twist", "")).strip(),
             "release": str(card.get("release", "")).strip(),
         },
-        "micro_loop": [
-            "Choose the right lens first: deeper, higher, wider, or rotated.",
-            "Make one pass sleeker by removing friction and generic weight.",
-            "Make one pass playful or progressive by trying one meaningful shift in angle.",
-        ],
+        "micro_loop": [str(row).strip() for row in micro_loop if str(row).strip()],
+    }
+
+
+def _agent_mode_breakdown(mode: dict[str, Any], *, topic: str = "") -> dict[str, Any]:
+    sequence = mode.get("breakdown_sequence", [])
+    if not isinstance(sequence, list) or not sequence:
+        raise RuntimeError("This mode does not define a breakdown sequence.")
+
+    normalized_sequence: list[dict[str, str]] = []
+    for row in sequence:
+        if not isinstance(row, dict):
+            continue
+        normalized_sequence.append(
+            {
+                "level_id": str(row.get("level_id", row.get("level", ""))).strip(),
+                "title": str(row.get("title", row.get("label", ""))).strip(),
+                "purpose": str(row.get("purpose", "")).strip(),
+                "prompt": str(row.get("prompt", row.get("question", ""))).strip(),
+                "output": str(row.get("output", "")).strip(),
+                "completion_check": str(row.get("completion_check", "")).strip(),
+            }
+        )
+
+    artifact_rule = str(mode.get("durable_artifact_rule", mode.get("artifact_rule", ""))).strip()
+    output_contract = [
+        str(row).strip()
+        for row in mode.get(
+            "breakdown_output_contract",
+            [
+                "Broad Frame",
+                "Boundary",
+                "Major Lanes",
+                "Subclaims",
+                "Atomic Obligations",
+                "Dependency Ladder",
+                "Active Target",
+                "Durable Checklist",
+                "Next Verification",
+            ],
+        )
+        if str(row).strip()
+    ]
+
+    return {
+        "mode": _agent_mode_public_payload(mode),
+        "topic": str(topic or "").strip(),
+        "sequence": normalized_sequence,
+        "durable_artifact_rule": artifact_rule,
+        "artifact_rule": artifact_rule,
+        "output_contract": output_contract,
     }
 
 
@@ -3443,6 +3666,9 @@ def _hosted_api_error(
     payload: dict[str, Any] | None,
 ) -> HostedApiError:
     message = str((payload or {}).get("error") or (payload or {}).get("message") or f"Request failed: {status}")
+    stripped_message = message.lstrip()
+    if stripped_message.startswith("<!DOCTYPE html") or stripped_message.startswith("<html"):
+        message = "Hosted ORP returned an HTML error page instead of JSON"
     suffix = f" (status={status} path={path})"
     hint = ""
     if status == 401:
@@ -3450,7 +3676,13 @@ def _hosted_api_error(
     elif status == 403:
         hint = " The hosted ORP app rejected the operation. Check permissions on the target record."
     elif status == 404:
-        hint = " The hosted record may have changed. Re-list the resource and retry."
+        if message == "Hosted ORP returned an HTML error page instead of JSON":
+            hint = (
+                " The hosted API route may not be deployed at this base URL. "
+                "Check ORP_BASE_URL or deploy the hosted ORP app."
+            )
+        else:
+            hint = " The hosted record may have changed. Re-list the resource and retry."
     elif status == 409:
         hint = " The hosted record changed since you last fetched it. Re-open it and retry the update."
     return HostedApiError(f"{message}{suffix}.{hint}".replace("..", "."))
@@ -10632,6 +10864,7 @@ def _about_payload() -> dict[str, Any]:
             {"name": "mode_list", "path": ["mode", "list"], "json_output": True},
             {"name": "mode_show", "path": ["mode", "show"], "json_output": True},
             {"name": "mode_nudge", "path": ["mode", "nudge"], "json_output": True},
+            {"name": "mode_breakdown", "path": ["mode", "breakdown"], "json_output": True},
             {"name": "secrets_list", "path": ["secrets", "list"], "json_output": True},
             {"name": "secrets_show", "path": ["secrets", "show"], "json_output": True},
             {"name": "secrets_add", "path": ["secrets", "add"], "json_output": True},
@@ -10734,7 +10967,7 @@ def _about_payload() -> dict[str, Any]:
             "Knowledge exchange is a built-in ORP ability exposed through `orp exchange repo synthesize`, producing structured exchange artifacts and transfer maps for local or remote source repositories.",
             "Collaboration is a built-in ORP ability exposed through `orp collaborate ...`.",
             "Frontier control is a built-in ORP ability exposed through `orp frontier ...`, separating the exact live point, the exact active milestone, the near structured checklist, and the farther major-version stack.",
-            "Agent modes are lightweight optional overlays for taste, perspective shifts, and fresh movement; `orp mode nudge sleek-minimal-progressive --json` gives agents a deterministic reminder they can call on when they want a deeper, wider, top-down, or rotated lens without changing ORP's core artifact boundaries.",
+            "Agent modes are lightweight optional overlays for taste, perspective shifts, fresh movement, and intentional comprehension breakdowns; `orp mode breakdown granular-breakdown --json` gives agents a broad-to-atomic ladder for complex work, while `orp mode nudge granular-breakdown --json` gives a short reminder card.",
             "Project/session linking is a built-in ORP ability exposed through `orp link ...` and stored machine-locally under `.git/orp/link/`.",
             "Secrets are easiest to understand as saved credentials and related login metadata: humans usually run `orp secrets add ...` and paste the value at the prompt, agents usually pipe the value with `--value-stdin`, optional usernames can be stored alongside the secret when a service needs them, and local macOS Keychain caching plus hosted sync are optional layers on top.",
             "Connections give ORP one place to remember service accounts, public data sources, deployment targets, and which saved secret alias or named secret bindings power each integration through `orp connections providers`, `orp connections list`, `orp connections show`, `orp connections add`, `orp connections update`, `orp connections remove`, `orp connections sync`, and `orp connections pull`.",
@@ -10890,6 +11123,10 @@ def _home_payload(repo_root: Path, config_arg: str) -> dict[str, Any]:
             "label": "Get an optional creativity/perspective nudge",
             "command": "orp mode nudge sleek-minimal-progressive --json",
         },
+        {
+            "label": "Break complex work into smaller intentional steps",
+            "command": "orp mode breakdown granular-breakdown --json",
+        },
     ]
 
     quick_actions = [
@@ -10993,6 +11230,14 @@ def _home_payload(repo_root: Path, config_arg: str) -> dict[str, Any]:
             "label": "Get an optional creative perspective nudge for agent work",
             "command": "orp mode nudge sleek-minimal-progressive --json",
         },
+        {
+            "label": "Get an optional breakdown nudge when work needs more granularity",
+            "command": "orp mode nudge granular-breakdown --json",
+        },
+        {
+            "label": "Generate a broad-to-atomic breakdown ladder for complex work",
+            "command": "orp mode breakdown granular-breakdown --json",
+        },
         {
             "label": "List first-class hosted workspaces",
             "command": "orp workspaces list --json",
@@ -11356,11 +11601,14 @@ def _home_payload(repo_root: Path, config_arg: str) -> dict[str, Any]:
             },
             {
                 "id": "modes",
-                "description": "Lightweight optional cognitive overlays for taste, creativity, perspective shifts, and exploratory momentum.",
+                "description": "Lightweight optional cognitive overlays for taste, creativity, perspective shifts, exploratory momentum, and granular comprehension breakdowns.",
                 "entrypoints": [
                     "orp mode list --json",
                     "orp mode show sleek-minimal-progressive --json",
                     "orp mode nudge sleek-minimal-progressive --json",
+                    "orp mode show granular-breakdown --json",
+                    "orp mode nudge granular-breakdown --json",
+                    "orp mode breakdown granular-breakdown --json",
                 ],
             },
             {
@@ -15024,6 +15272,7 @@ def cmd_mode_show(args: argparse.Namespace) -> int:
             ("mode.activation_phrase", mode_payload["activation_phrase"]),
             ("mode.invocation_style", mode_payload["invocation_style"]),
             ("mode.nudge_card_count", mode_payload["nudge_card_count"]),
+            ("mode.breakdown_sequence_count", mode_payload["breakdown_sequence_count"]),
         ]
     )
     for key in ("when_to_use", "perspective_shifts", "principles", "ritual", "questions", "anti_patterns"):
@@ -15064,6 +15313,43 @@ def cmd_mode_nudge(args: argparse.Namespace) -> int:
     return 0
 
 
+def cmd_mode_breakdown(args: argparse.Namespace) -> int:
+    mode = _agent_mode(getattr(args, "mode_ref", ""))
+    payload = {
+        "ok": True,
+        **_agent_mode_breakdown(mode, topic=str(getattr(args, "topic", "") or "").strip()),
+    }
+    if args.json_output:
+        _print_json(payload)
+        return 0
+
+    pairs = [
+        ("mode.id", payload["mode"]["id"]),
+        ("mode.label", payload["mode"]["label"]),
+        ("mode.activation_phrase", payload["mode"]["activation_phrase"]),
+    ]
+    if payload["topic"]:
+        pairs.append(("breakdown.topic", payload["topic"]))
+    pairs.append(("breakdown.sequence_count", len(payload["sequence"])))
+    _print_pairs(pairs)
+
+    print("breakdown.sequence:")
+    for index, row in enumerate(payload["sequence"], start=1):
+        title = row.get("title", "")
+        level_id = row.get("level_id", "")
+        print(f"{index}. {title} [{level_id}]")
+        for key in ("purpose", "prompt", "output", "completion_check"):
+            value = str(row.get(key, "")).strip()
+            if value:
+                print(f"   {key}: {value}")
+    if payload["durable_artifact_rule"]:
+        print(f"durable_artifact_rule={payload['durable_artifact_rule']}")
+    print("output_contract:")
+    for row in payload["output_contract"]:
+        print(f"- {row}")
+    return 0
+
+
 def cmd_update(args: argparse.Namespace) -> int:
     payload = _update_payload()
     if getattr(args, "yes", False):
@@ -22357,7 +22643,7 @@ def build_parser() -> argparse.ArgumentParser:
 
     s_mode = sub.add_parser(
         "mode",
-        help="Agent-first creative and cognitive overlay modes",
+        help="Agent-first cognitive overlay modes for creativity, perspective, and breakdown",
     )
     mode_sub = s_mode.add_subparsers(dest="mode_cmd", required=True)
 
@@ -22372,7 +22658,7 @@ def build_parser() -> argparse.ArgumentParser:
 
     s_mode_nudge = mode_sub.add_parser(
         "nudge",
-        help="Return a deterministic creativity nudge card for one agent mode",
+        help="Return a deterministic nudge card for one agent mode",
     )
     s_mode_nudge.add_argument("mode_ref", help="Mode id or alias")
     s_mode_nudge.add_argument(
@@ -22383,6 +22669,19 @@ def build_parser() -> argparse.ArgumentParser:
     add_json_flag(s_mode_nudge)
     s_mode_nudge.set_defaults(func=cmd_mode_nudge, json_output=False)
 
+    s_mode_breakdown = mode_sub.add_parser(
+        "breakdown",
+        help="Return a broad-to-atomic breakdown ladder for one agent mode",
+    )
+    s_mode_breakdown.add_argument("mode_ref", help="Mode id or alias")
+    s_mode_breakdown.add_argument(
+        "--topic",
+        default="",
+        help="Optional topic label for the breakdown target",
+    )
+    add_json_flag(s_mode_breakdown)
+    s_mode_breakdown.set_defaults(func=cmd_mode_breakdown, json_output=False)
+
     s_update = sub.add_parser(
         "update",
         help="Check npm for a newer ORP release and print the recommended upgrade command",

package/docs/AGENT_LOOP.md

@@ -16,6 +16,11 @@ read:
   exploratory reframing, run:
   - `orp mode nudge sleek-minimal-progressive --json`
   - Treat it as an optional lens for deeper, wider, top-down, or rotated perspective shifts.
+- If the task feels confusing, too large to hold at once, or likely to benefit
+  from more intentional granularity, run:
+  - `orp mode breakdown granular-breakdown --json`
+  - Optionally follow with `orp mode nudge granular-breakdown --json` if you only need a short reminder card.
+  - Treat it as a broad-to-atomic ladder: whole frame, boundary, major lanes, subclaims, atomic obligations, dependency order, durable checklist, and next verification.
 - If packs matter, run `orp pack list --json`.
 - Read `PROTOCOL.md` before making claims.
 - If the repo uses parent/child agent guidance, run `orp agents audit --json` so you know `AGENTS.md` and `CLAUDE.md` are aligned before taking a long-running path.

package/docs/AGENT_MODES.md

@@ -77,3 +77,49 @@ Use this when the work needs bigger options before it needs tighter polish.
 - import principles from other domains
 - keep one unreasonable idea alive long enough to inspect it
 - prune only after a genuinely bold pass exists
+
+### `granular-breakdown`
+
+Use this when the work needs more intentional granularity so the user, agent,
+or future collaborator can actually understand and continue it.
+
+- name the whole problem plainly
+- split the work into current state, desired state, and missing bridge
+- order steps by dependency, risk, and comprehension
+- choose one small verification that proves movement
+- compress the result back into a clear summary after the breakdown
+
+Recommended commands:
+
+```bash
+orp mode show granular-breakdown --json
+orp mode breakdown granular-breakdown --json
+orp mode nudge granular-breakdown --json
+```
+
+Use `breakdown` when the task needs a real ladder from broad framing to atomic
+subtasks or sub-lemmas. Use `nudge` when the agent only needs a compact reminder
+card for the next pass.
+
+Use this regularly as part of the research/development loop when:
+
+- the user asks what a feature, command, or error means
+- the plan is correct but too large to hold at once
+- a repo handoff needs to be understandable to the next agent
+- a high-level goal needs to become a safe sequence of small moves
+
+The full breakdown ladder is:
+
+- whole frame
+- boundary
+- major lanes
+- subclaims
+- atomic obligations
+- dependency ladder
+- active target
+- durable checklist
+- next verification
+
+If the breakdown becomes operationally important, promote it into a durable
+checklist artifact with stable IDs, dependencies, statuses, source artifacts,
+falsifier boundaries, and the first active target.

package/docs/START_HERE.md

@@ -191,6 +191,17 @@ If you want ORP to remember an ongoing repo path plus a resumable session, add i
 orp workspace add-tab main --path /absolute/path/to/project --remote-url git@github.com:org/project.git --bootstrap-command "npm install" --resume-command "codex resume <session-id>"
 ```
 
+If the same project has more than one active thread, append another session for
+that path:
+
+```bash
+orp workspace add-tab main --path /absolute/path/to/project --title "release hardening" --resume-tool codex --resume-session-id <session-id> --append
+```
+
+ORP keeps the flat `tabs` list for copyable recovery order, and also stores a
+grouped `projects` object so all sessions for the same repo live together under
+`projects[].sessions[]`.
+
 For Claude:
 
 ```bash
@@ -652,12 +663,22 @@ When the work feels too linear, too trapped, or too narrow:
 orp mode nudge sleek-minimal-progressive --json
 ```
 
-This is optional. It does not override the protocol. It just gives the agent or operator a lightweight perspective shift.
+When the work feels too big, confusing, or hard to sequence:
+
+```bash
+orp mode breakdown granular-breakdown --json
+orp mode nudge granular-breakdown --json
+```
+
+Use `breakdown` for the full broad-to-atomic ladder and `nudge` for a short
+reminder card. Both are optional. They do not override the protocol. They just
+give the agent or operator a clearer thinking scaffold.
 
 It is there to help with:
 
 - getting unstuck
 - zooming in or out
+- breaking complex work into smaller intentional steps
 - rotating the angle of attack
 - keeping the work fresh without making the workflow sloppy
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-research-protocol",
-  "version": "0.4.21",
+  "version": "0.4.23",
   "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/README.md

@@ -34,8 +34,15 @@ Add a new saved tab manually:
 orp workspace ledger add main --path /absolute/path/to/frg-site --resume-command "codex resume 019d348d-5031-78e1-9840-a66deaac33ae"
 orp workspace add-tab main --path /absolute/path/to/anthropic-lab --resume-tool claude --resume-session-id claude-456
 orp workspace add-tab main --path /absolute/path/to/orp-web-app --remote-url git@github.com:SproutSeeds/orp-web-app.git --bootstrap-command "pnpm install"
+orp workspace add-tab main --path /absolute/path/to/orp --title "release hardening" --resume-tool codex --resume-session-id 019d32d3-d8b2-7fa2-aaec-c74b5134afd6 --append
 ```
 
+When several saved sessions point at the same project path, ORP now also writes
+a grouped `projects` object in the manifest. The flat `tabs` list remains for
+older tools, but agents should prefer `projects[].sessions[]` when they need to
+understand all active Codex or Claude threads for one repo before pruning or
+sunsetting a session.
+
 Remove a saved tab manually:
 
 ```bash

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

@@ -282,6 +282,37 @@ function normalizeStructuredTab(rawTab, index) {
   };
 }
 
+function normalizeStructuredProject(rawProject, projectIndex) {
+  if (!rawProject || typeof rawProject !== "object" || Array.isArray(rawProject)) {
+    throw new Error(`workspace project ${projectIndex + 1} must be an object`);
+  }
+
+  const projectPath = validateAbsolutePath(rawProject.path, `workspace project ${projectIndex + 1} path`);
+  const sessions = Array.isArray(rawProject.sessions) && rawProject.sessions.length > 0 ? rawProject.sessions : [{}];
+
+  return sessions.map((rawSession, sessionIndex) => {
+    if (!rawSession || typeof rawSession !== "object" || Array.isArray(rawSession)) {
+      throw new Error(`workspace project ${projectIndex + 1} session ${sessionIndex + 1} must be an object`);
+    }
+    return normalizeStructuredTab(
+      {
+        title: rawSession.title ?? rawProject.title,
+        path: projectPath,
+        remoteUrl: rawSession.remoteUrl ?? rawProject.remoteUrl,
+        remoteBranch: rawSession.remoteBranch ?? rawProject.remoteBranch,
+        bootstrapCommand: rawSession.bootstrapCommand ?? rawProject.bootstrapCommand,
+        resumeCommand: rawSession.resumeCommand,
+        resumeTool: rawSession.resumeTool,
+        resumeSessionId: rawSession.resumeSessionId ?? rawSession.sessionId,
+        codexSessionId: rawSession.codexSessionId,
+        claudeSessionId: rawSession.claudeSessionId,
+        tmuxSessionName: rawSession.tmuxSessionName,
+      },
+      sessionIndex,
+    );
+  });
+}
+
 export function normalizeWorkspaceManifest(rawManifest) {
   if (!rawManifest || typeof rawManifest !== "object" || Array.isArray(rawManifest)) {
     throw new Error("workspace manifest must be a JSON object");
@@ -292,11 +323,15 @@ export function normalizeWorkspaceManifest(rawManifest) {
     throw new Error(`unsupported workspace manifest version: ${version}`);
   }
 
-  if (!Array.isArray(rawManifest.tabs)) {
-    throw new Error("workspace manifest must include a tabs array");
+  const hasProjects = Array.isArray(rawManifest.projects);
+  const hasTabs = Array.isArray(rawManifest.tabs);
+  if (!hasProjects && !hasTabs) {
+    throw new Error("workspace manifest must include a tabs array or projects array");
   }
 
-  const tabs = rawManifest.tabs.map((tab, index) => normalizeStructuredTab(tab, index));
+  const tabs = hasProjects
+    ? rawManifest.projects.flatMap((project, index) => normalizeStructuredProject(project, index))
+    : rawManifest.tabs.map((tab, index) => normalizeStructuredTab(tab, index));
   return {
     version,
     workspaceId: normalizeOptionalString(rawManifest.workspaceId),
@@ -334,6 +369,57 @@ export function deriveBaseTitle(entry) {
   return path.basename(normalized) || normalized;
 }
 
+export function buildWorkspaceProjectGroups(entries = []) {
+  const groups = new Map();
+
+  for (const entry of entries) {
+    const projectPath = validateAbsolutePath(entry.path, "workspace project path");
+    if (!groups.has(projectPath)) {
+      groups.set(projectPath, {
+        title: deriveBaseTitle(entry),
+        path: projectPath,
+        remoteUrl: normalizeOptionalUrl(entry.remoteUrl, "workspace project remoteUrl"),
+        remoteBranch: normalizeOptionalString(entry.remoteBranch),
+        bootstrapCommand: normalizeOptionalCommand(entry.bootstrapCommand),
+        sessions: [],
+      });
+    }
+
+    const project = groups.get(projectPath);
+    project.remoteUrl = project.remoteUrl || normalizeOptionalUrl(entry.remoteUrl, "workspace project remoteUrl");
+    project.remoteBranch = project.remoteBranch || normalizeOptionalString(entry.remoteBranch);
+    project.bootstrapCommand = project.bootstrapCommand || normalizeOptionalCommand(entry.bootstrapCommand);
+
+    const resume = resolveResumeMetadata(entry);
+    project.sessions.push(
+      Object.fromEntries(
+        Object.entries({
+          title: normalizeOptionalString(entry.title) || deriveBaseTitle(entry),
+          resumeCommand: resume.resumeCommand || undefined,
+          resumeTool: resume.resumeTool || undefined,
+          resumeSessionId: resume.resumeSessionId || undefined,
+          codexSessionId: resume.resumeTool === "codex" ? resume.resumeSessionId || undefined : undefined,
+          claudeSessionId: resume.resumeTool === "claude" ? resume.resumeSessionId || undefined : undefined,
+        }).filter(([, value]) => value !== undefined),
+      ),
+    );
+  }
+
+  return [...groups.values()].map((project) =>
+    Object.fromEntries(
+      Object.entries({
+        title: project.title,
+        path: project.path,
+        remoteUrl: project.remoteUrl || undefined,
+        remoteBranch: project.remoteBranch || undefined,
+        bootstrapCommand: project.bootstrapCommand || undefined,
+        sessionCount: project.sessions.length,
+        sessions: project.sessions,
+      }).filter(([, value]) => value !== undefined),
+    ),
+  );
+}
+
 export function deriveTmuxSessionName(entry, options = {}) {
   if (entry.tmuxSessionName && String(entry.tmuxSessionName).trim().length > 0) {
     return String(entry.tmuxSessionName).trim();

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

@@ -97,6 +97,59 @@ function matchPreviousHostedTab(tab, previousTabs) {
   return match;
 }
 
+function buildHostedProjectGroups(tabs) {
+  const groups = new Map();
+  for (const tab of tabs) {
+    const projectRoot = normalizeOptionalString(tab.project_root);
+    if (!projectRoot) {
+      continue;
+    }
+    if (!groups.has(projectRoot)) {
+      groups.set(projectRoot, {
+        title: normalizeOptionalString(tab.repo_label) || path.basename(String(projectRoot).replace(/\/+$/, "")) || projectRoot,
+        project_root: projectRoot,
+        remote_url: normalizeOptionalString(tab.remote_url),
+        remote_branch: normalizeOptionalString(tab.remote_branch),
+        bootstrap_command: normalizeOptionalString(tab.bootstrap_command),
+        sessions: [],
+      });
+    }
+    const project = groups.get(projectRoot);
+    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.sessions.push(
+      Object.fromEntries(
+        Object.entries({
+          tab_id: normalizeOptionalString(tab.tab_id),
+          title: normalizeOptionalString(tab.title),
+          resume_command: normalizeOptionalString(tab.resume_command),
+          resume_tool: normalizeOptionalString(tab.resume_tool),
+          resume_session_id: normalizeOptionalString(tab.resume_session_id),
+          codex_session_id: normalizeOptionalString(tab.codex_session_id),
+          claude_session_id: normalizeOptionalString(tab.claude_session_id),
+          status: normalizeOptionalString(tab.status),
+          current_task: normalizeOptionalString(tab.current_task),
+        }).filter(([, value]) => value !== undefined && value !== null),
+      ),
+    );
+  }
+
+  return [...groups.values()].map((project) =>
+    Object.fromEntries(
+      Object.entries({
+        title: project.title,
+        project_root: project.project_root,
+        remote_url: project.remote_url || undefined,
+        remote_branch: project.remote_branch || undefined,
+        bootstrap_command: project.bootstrap_command || undefined,
+        session_count: project.sessions.length,
+        sessions: project.sessions,
+      }).filter(([, value]) => value !== undefined && value !== null),
+    ),
+  );
+}
+
 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");
@@ -172,6 +225,7 @@ export function buildHostedWorkspaceState(manifest, options = {}) {
       }).filter(([, value]) => value !== undefined && value !== null),
     );
   });
+  const projects = buildHostedProjectGroups(tabs);
 
   const captureContext = Object.fromEntries(
     Object.entries({
@@ -210,7 +264,9 @@ export function buildHostedWorkspaceState(manifest, options = {}) {
       captured_at_utc: capturedAt,
       updated_at_utc: updatedAt,
       tab_count: tabs.length,
+      project_count: projects.length,
       capture_context: Object.keys(captureContext).length > 0 ? captureContext : undefined,
+      projects,
       tabs,
     }).filter(([, value]) => value !== undefined && value !== null),
   );

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

@@ -5,6 +5,7 @@ import process from "node:process";
 
 import {
   buildDirectCommand,
+  buildWorkspaceProjectGroups,
   deriveBaseTitle,
   normalizeWorkspaceManifest,
   parseWorkspaceSource,
@@ -110,6 +111,7 @@ function buildWorkspaceResultTab(tab) {
 
 function materializeWorkspaceManifest(manifest) {
   const normalized = normalizeWorkspaceManifest(manifest);
+  const tabs = normalized.tabs.map((tab) => materializeWorkspaceTab(tab));
   return Object.fromEntries(
     Object.entries({
       version: normalized.version,
@@ -117,7 +119,8 @@ function materializeWorkspaceManifest(manifest) {
       title: normalized.title || undefined,
       machine: normalized.machine || undefined,
       capture: normalized.capture || undefined,
-      tabs: normalized.tabs.map((tab) => materializeWorkspaceTab(tab)),
+      projects: buildWorkspaceProjectGroups(normalized.tabs),
+      tabs,
     }).filter(([, value]) => value !== undefined),
   );
 }
@@ -670,7 +673,7 @@ Options:
   --resume-tool <tool>   Build the resume command from \`codex\` or \`claude\`
   --resume-session-id <id> Resume session id to save with the tab
   --current-codex        Save the current \`CODEX_THREAD_ID\` as a Codex resume target
-  --append               Always append a new saved tab instead of updating an existing matching tab
+  --append               Add another saved session for the same project path instead of updating the existing one
   --hosted-workspace-id <id> Edit a first-class hosted workspace directly
   --workspace-file <path> Edit a local structured workspace manifest
   --json                 Print the updated workspace edit result as JSON
@@ -681,6 +684,7 @@ Examples:
   orp workspace add-tab main --here --current-codex
   orp workspace add-tab main --path /absolute/path/to/new-project --resume-command "codex resume 019d..."
   orp workspace add-tab main --path /absolute/path/to/new-project --resume-tool claude --resume-session-id claude-456
+  orp workspace add-tab main --path /absolute/path/to/new-project --title "second active thread" --resume-tool codex --resume-session-id 019d... --append
   orp workspace add-tab main --path /absolute/path/to/new-project --remote-url git@github.com:org/new-project.git --bootstrap-command "npm install"
 `);
 }

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

@@ -2,6 +2,7 @@ import process from "node:process";
 import { createInterface } from "node:readline/promises";
 
 import {
+  buildWorkspaceProjectGroups,
   deriveBaseTitle,
   deriveWorkspaceId,
   getResumeCommand,
@@ -208,6 +209,7 @@ function serializeWorkspaceManifest(manifest) {
       }).filter(([, value]) => value !== undefined),
     ),
   );
+  const projects = buildWorkspaceProjectGroups(manifest.tabs);
 
   const normalized = Object.fromEntries(
     Object.entries({
@@ -215,6 +217,7 @@ function serializeWorkspaceManifest(manifest) {
       workspaceId: normalizeOptionalString(manifest.workspaceId) ?? undefined,
       title: normalizeOptionalString(manifest.title) ?? undefined,
       machine: manifest.machine ?? undefined,
+      projects,
       tabs,
     }).filter(([, value]) => value !== undefined),
   );

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

@@ -5,6 +5,7 @@ import {
   buildDirectCommand,
   buildLaunchPlan,
   buildSetupCommand,
+  buildWorkspaceProjectGroups,
   deriveWorkspaceId,
   getResumeCommand,
   parseWorkspaceSource,
@@ -63,6 +64,7 @@ export function buildWorkspaceTabsReport(source, parsed, options = {}) {
     tmux: false,
     resume: true,
   });
+  const projectGroups = buildWorkspaceProjectGroups(launchTabs);
 
   return {
     sourceType: source.sourceType,
@@ -72,7 +74,24 @@ export function buildWorkspaceTabsReport(source, parsed, options = {}) {
     machine: parsed.manifest?.machine || null,
     parseMode: parsed.parseMode,
     tabCount: launchTabs.length,
+    projectCount: projectGroups.length,
     skippedCount: parsed.skipped.length,
+    projects: projectGroups.map((project) => ({
+      ...project,
+      sessions: project.sessions.map((session) => ({
+        ...session,
+        restartCommand: buildDirectCommand(
+          {
+            path: project.path,
+            resumeCommand: session.resumeCommand || null,
+            resumeTool: session.resumeTool || null,
+            resumeSessionId: session.resumeSessionId || null,
+            sessionId: session.resumeSessionId || null,
+          },
+          { resume: true },
+        ),
+      })),
+    })),
     tabs: launchTabs.map((tab, index) => ({
       index: index + 1,
       title: tab.title,
@@ -116,6 +135,7 @@ export function summarizeWorkspaceTabs(report) {
           }${report.machine.machineId ? ` [${report.machine.machineId}]` : ""}`,
         ]
       : []),
+    `Saved projects: ${report.projectCount}`,
     `Saved tabs: ${report.tabCount}`,
     `Parse mode: ${report.parseMode}`,
     "",
@@ -172,6 +192,7 @@ Options:
 
 Notes:
   - This shows the saved tab order plus any stored local path, remote repo, bootstrap command, and \`codex resume ...\` / \`claude --resume ...\` metadata.
+  - JSON output includes grouped \`projects[].sessions[]\` so duplicate project paths can be reviewed and sunset together.
   - The human-readable \`resume:\` line is already copyable and includes the saved \`cd ... && resume ...\` recovery command.
   - When a tab also has \`remote:\` or \`setup:\` lines, those are the portable cross-machine clues for cloning and preparing the repo on another rig.
   - The selector can be \`main\`, \`offhand\`, a hosted idea id, a hosted workspace id, a local workspace id, or a saved workspace title/slug.

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

@@ -243,6 +243,40 @@ test("addTabToManifest asks for a title when multiple saved tabs share a path",
   );
 });
 
+test("normalizeWorkspaceManifest expands grouped project sessions", () => {
+  const manifest = normalizeWorkspaceManifest({
+    version: "1",
+    workspaceId: "main-cody-1",
+    title: "main-cody-1",
+    projects: [
+      {
+        title: "orp",
+        path: "/Volumes/Code_2TB/code/orp",
+        remoteUrl: "git@github.com:SproutSeeds/orp.git",
+        sessions: [
+          {
+            title: "orp release",
+            resumeTool: "codex",
+            resumeSessionId: "019d32d3-d8b2-7fa2-aaec-c74b5134afd6",
+          },
+          {
+            title: "orp docs",
+            resumeCommand: "claude --resume 469d99b2-2997-42bf-a8f5-3812c808ef29",
+          },
+        ],
+      },
+    ],
+  });
+
+  assert.equal(manifest.tabs.length, 2);
+  assert.equal(manifest.tabs[0]?.path, "/Volumes/Code_2TB/code/orp");
+  assert.equal(manifest.tabs[0]?.title, "orp release");
+  assert.equal(manifest.tabs[0]?.resumeTool, "codex");
+  assert.equal(manifest.tabs[1]?.title, "orp docs");
+  assert.equal(manifest.tabs[1]?.resumeTool, "claude");
+  assert.equal(manifest.tabs[1]?.sessionId, "469d99b2-2997-42bf-a8f5-3812c808ef29");
+});
+
 test("removeTabsFromManifest can target a saved tab by path and resume session id", () => {
   const result = removeTabsFromManifest(sampleManifest(), {
     path: "/Volumes/Code_2TB/code/frg-site",
@@ -328,6 +362,44 @@ test("runWorkspaceAddTab upserts an existing tab and returns the rendered recove
   });
 });
 
+test("runWorkspaceAddTab stores same-project sessions under a grouped project object", async () => {
+  await withTempConfigHome(async () => {
+    const tempDir = await makeTempDir();
+    const manifestPath = path.join(tempDir, "workspace.json");
+    await fs.writeFile(manifestPath, `${JSON.stringify(sampleManifest(), null, 2)}\n`, "utf8");
+
+    const { code, stdout } = await captureStdout(() =>
+      runWorkspaceAddTab([
+        "--workspace-file",
+        manifestPath,
+        "--path",
+        "/Volumes/Code_2TB/code/orp",
+        "--title",
+        "orp second session",
+        "--resume-tool",
+        "codex",
+        "--resume-session-id",
+        "019d32d3-d8b2-7fa2-aaec-c74b5134afd6",
+        "--append",
+        "--json",
+      ]),
+    );
+    const payload = JSON.parse(stdout);
+    const saved = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+
+    assert.equal(code, 0);
+    assert.equal(payload.action, "add-tab");
+    assert.equal(payload.mutation, "added");
+    assert.equal(payload.tabCount, 3);
+    const orpProject = saved.projects.find((project) => project.path === "/Volumes/Code_2TB/code/orp");
+    assert.ok(orpProject);
+    assert.equal(orpProject.sessionCount, 2);
+    assert.equal(orpProject.sessions[1]?.title, "orp second session");
+    assert.equal(orpProject.sessions[1]?.resumeCommand, "codex resume 019d32d3-d8b2-7fa2-aaec-c74b5134afd6");
+    assert.equal(saved.tabs.length, 3);
+  });
+});
+
 test("runWorkspaceRemoveTab updates a local workspace manifest file", async () => {
   await withTempConfigHome(async () => {
     const tempDir = await makeTempDir();

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

@@ -93,6 +93,10 @@ test("buildWorkspaceTabsReport keeps duplicate titles unique and exposes generic
   assert.equal(report.workspaceId, "workspace-idea");
   assert.equal(report.machine?.machineLabel, "Mac Studio");
   assert.equal(report.tabCount, 3);
+  assert.equal(report.projectCount, 2);
+  assert.equal(report.projects[0]?.path, "/Volumes/Code_2TB/code/collaboration");
+  assert.equal(report.projects[0]?.sessionCount, 2);
+  assert.equal(report.projects[0]?.sessions[0]?.restartCommand, "cd '/Volumes/Code_2TB/code/collaboration' && codex resume abc-123");
   assert.equal(report.tabs[0]?.title, "collaboration");
   assert.equal(report.tabs[0]?.remoteUrl, "git@github.com:org/collaboration.git");
   assert.equal(report.tabs[0]?.bootstrapCommand, "npm install");
@@ -163,6 +167,8 @@ test("runWorkspaceTabs prints JSON without launch commands", async () => {
   assert.equal(parsed.workspaceId, "orp-main");
   assert.equal(parsed.machine.machineLabel, "Mac Studio");
   assert.equal(parsed.tabCount, 2);
+  assert.equal(parsed.projectCount, 2);
+  assert.equal(parsed.projects[0]?.sessions[0]?.restartCommand, "cd '/Volumes/Code_2TB/code/orp' && claude resume claude-999");
   assert.equal(parsed.tabs[0]?.title, "orp");
   assert.equal(parsed.tabs[0]?.remoteUrl, "git@github.com:SproutSeeds/orp.git");
   assert.equal(parsed.tabs[0]?.bootstrapCommand, "npm install");

package/scripts/orp-kernel-benchmark.py

@@ -26,6 +26,7 @@ ARTIFACT_CLASSES = [
     "policy",
     "result",
 ]
+QUICK_PERFORMANCE_TARGET_MULTIPLIER = 1.5
 VALID_REQUIREMENT_FIXTURES: dict[str, dict[str, Any]] = {
     "task": {
         "schema_version": "1.0.0",
@@ -507,6 +508,54 @@ def _benchmark_cross_domain_corpus() -> dict[str, Any]:
     }
 
 
+def _relax_mean_target(benchmark: dict[str, Any], *, observed_key: str, target_key: str, meets_key: str) -> None:
+    targets = benchmark.get("targets")
+    observed = benchmark.get("observed")
+    meets_targets = benchmark.get("meets_targets")
+    if not isinstance(targets, dict) or not isinstance(observed, dict) or not isinstance(meets_targets, dict):
+        return
+    current_target = targets.get(target_key)
+    current_observed = (observed.get(observed_key) or {}).get("mean_ms")
+    if not isinstance(current_target, (int, float)) or not isinstance(current_observed, (int, float)):
+        return
+    next_target = round(float(current_target) * QUICK_PERFORMANCE_TARGET_MULTIPLIER, 3)
+    targets[target_key] = next_target
+    meets_targets[meets_key] = float(current_observed) < next_target
+
+
+def _apply_quick_performance_targets(
+    *,
+    init_benchmark: dict[str, Any],
+    roundtrip_benchmark: dict[str, Any],
+    corpus_benchmark: dict[str, Any],
+    requirement_benchmark: dict[str, Any],
+    mutation_stress: dict[str, Any],
+) -> None:
+    _relax_mean_target(init_benchmark, observed_key="init", target_key="init_mean_lt_ms", meets_key="init")
+    _relax_mean_target(init_benchmark, observed_key="validate", target_key="validate_mean_lt_ms", meets_key="validate")
+    _relax_mean_target(init_benchmark, observed_key="gate_run", target_key="gate_mean_lt_ms", meets_key="gate_run")
+    _relax_mean_target(
+        roundtrip_benchmark,
+        observed_key="scaffold",
+        target_key="scaffold_mean_lt_ms",
+        meets_key="scaffold",
+    )
+    _relax_mean_target(
+        roundtrip_benchmark,
+        observed_key="validate",
+        target_key="validate_mean_lt_ms",
+        meets_key="validate",
+    )
+    _relax_mean_target(corpus_benchmark, observed_key="validate", target_key="validate_mean_lt_ms", meets_key="validate")
+    _relax_mean_target(
+        requirement_benchmark,
+        observed_key="validate",
+        target_key="validate_mean_lt_ms",
+        meets_key="validate",
+    )
+    _relax_mean_target(mutation_stress, observed_key="validate", target_key="validate_mean_lt_ms", meets_key="validate")
+
+
 def _benchmark_requirement_enforcement() -> dict[str, Any]:
     rows: list[dict[str, Any]] = []
     validate_times: list[float] = []
@@ -747,7 +796,7 @@ def _gather_metadata() -> dict[str, Any]:
     }
 
 
-def build_report(iterations: int) -> dict[str, Any]:
+def build_report(iterations: int, *, quick: bool = False) -> dict[str, Any]:
     init_benchmark = _benchmark_init_starter(iterations)
     roundtrip_benchmark = _benchmark_artifact_roundtrip()
     gate_mode_benchmark = _benchmark_gate_modes()
@@ -756,6 +805,14 @@ def build_report(iterations: int) -> dict[str, Any]:
     requirement_benchmark = _benchmark_requirement_enforcement()
     representation_invariance = _benchmark_representation_invariance()
     mutation_stress = _benchmark_mutation_stress()
+    if quick:
+        _apply_quick_performance_targets(
+            init_benchmark=init_benchmark,
+            roundtrip_benchmark=roundtrip_benchmark,
+            corpus_benchmark=corpus_benchmark,
+            requirement_benchmark=requirement_benchmark,
+            mutation_stress=mutation_stress,
+        )
 
     claims = [
         {
@@ -901,11 +958,15 @@ def main() -> int:
     parser = argparse.ArgumentParser(description="Benchmark and validate ORP Reasoning Kernel v0.1")
     parser.add_argument("--out", default="", help="Optional JSON output path")
     parser.add_argument("--iterations", type=int, default=5, help="Iterations for bootstrap benchmark")
-    parser.add_argument("--quick", action="store_true", help="Use a single bootstrap iteration for fast checks")
+    parser.add_argument(
+        "--quick",
+        action="store_true",
+        help="Use a single bootstrap iteration and relaxed local timing targets for fast smoke checks",
+    )
     args = parser.parse_args()
 
     iterations = 1 if args.quick else max(1, args.iterations)
-    report = build_report(iterations)
+    report = build_report(iterations, quick=args.quick)
     payload = json.dumps(report, indent=2) + "\n"
     if args.out:
         out_path = Path(args.out)